src/mesa/drivers/dri/i915/i830_state.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  **************************************************************************/
   7
   8
   9 #include "glheader.h"
  10 #include "context.h"
  11 #include "macros.h"
  12 #include "enums.h"
  13 #include "dd.h"
  14
  15 #include "texmem.h"
  16
  17 #include "intel_screen.h"
  18 #include "intel_batchbuffer.h"
  19
  20 #include "i830_context.h"
  21 #include "i830_reg.h"
  22
  23 static void i830StencilFunc(GLcontext *ctx, GLenum func, GLint ref,
  24                             GLuint mask)
  25 {
  26    i830ContextPtr i830 = I830_CONTEXT(ctx);
  27    int test = 0;
  28
  29    mask = mask & 0xff;
  30
  31    if (INTEL_DEBUG&DEBUG_DRI)
  32       fprintf(stderr, "%s : func: %s, ref : 0x%x, mask: 0x%x\n", __FUNCTION__,
  33               _mesa_lookup_enum_by_nr(func), ref, mask);
  34
  35    switch(func) {
  36    case GL_NEVER:
  37       test = COMPAREFUNC_NEVER;
  38       break;
  39    case GL_LESS:
  40       test = COMPAREFUNC_LESS;
  41       break;
  42    case GL_LEQUAL:
  43       test = COMPAREFUNC_LEQUAL;
  44       break;
  45    case GL_GREATER:
  46       test = COMPAREFUNC_GREATER;
  47       break;
  48    case GL_GEQUAL:
  49       test = COMPAREFUNC_GEQUAL;
  50       break;
  51    case GL_NOTEQUAL:
  52       test = COMPAREFUNC_NOTEQUAL;
  53       break;
  54    case GL_EQUAL:
  55       test = COMPAREFUNC_EQUAL;
  56       break;
  57    case GL_ALWAYS:
  58       test = COMPAREFUNC_ALWAYS;
  59       break;
  60    default:
  61       return;
  62    }
  63
  64    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
  65    i830->state.Ctx[I830_CTXREG_STATE4] &= ~MODE4_ENABLE_STENCIL_TEST_MASK;
  66    i830->state.Ctx[I830_CTXREG_STATE4] |= (ENABLE_STENCIL_TEST_MASK |
  67                                         STENCIL_TEST_MASK(mask));
  68    i830->state.Ctx[I830_CTXREG_STENCILTST] &= ~(STENCIL_REF_VALUE_MASK |
  69                                              ENABLE_STENCIL_TEST_FUNC_MASK);
  70    i830->state.Ctx[I830_CTXREG_STENCILTST] |= (ENABLE_STENCIL_REF_VALUE |
  71                                             ENABLE_STENCIL_TEST_FUNC |
  72                                             STENCIL_REF_VALUE(ref) |
  73                                             STENCIL_TEST_FUNC(test));
  74 }
  75
  76 static void i830StencilMask(GLcontext *ctx, GLuint mask)
  77 {
  78    i830ContextPtr i830 = I830_CONTEXT(ctx);
  79
  80    if (INTEL_DEBUG&DEBUG_DRI)
  81       fprintf(stderr, "%s : mask 0x%x\n", __FUNCTION__, mask);
  82
  83    mask = mask & 0xff;
  84
  85    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
  86    i830->state.Ctx[I830_CTXREG_STATE4] &= ~MODE4_ENABLE_STENCIL_WRITE_MASK;
  87    i830->state.Ctx[I830_CTXREG_STATE4] |= (ENABLE_STENCIL_WRITE_MASK |
  88                                         STENCIL_WRITE_MASK(mask));
  89 }
  90
  91 static void i830StencilOp(GLcontext *ctx, GLenum fail, GLenum zfail,
  92                           GLenum zpass)
  93 {
  94    i830ContextPtr i830 = I830_CONTEXT(ctx);
  95    int fop, dfop, dpop;
  96
  97    if (INTEL_DEBUG&DEBUG_DRI)
  98       fprintf(stderr, "%s: fail : %s, zfail: %s, zpass : %s\n", __FUNCTION__,
  99               _mesa_lookup_enum_by_nr(fail),
 100               _mesa_lookup_enum_by_nr(zfail),
 101               _mesa_lookup_enum_by_nr(zpass));
 102
 103    fop = 0; dfop = 0; dpop = 0;
 104
 105    switch(fail) {
 106    case GL_KEEP:
 107       fop = STENCILOP_KEEP;
 108       break;
 109    case GL_ZERO:
 110       fop = STENCILOP_ZERO;
 111       break;
 112    case GL_REPLACE:
 113       fop = STENCILOP_REPLACE;
 114       break;
 115    case GL_INCR:
 116       fop = STENCILOP_INCRSAT;
 117       break;
 118    case GL_DECR:
 119       fop = STENCILOP_DECRSAT;
 120       break;
 121    case GL_INCR_WRAP:
 122       fop = STENCILOP_INCR;
 123       break;
 124    case GL_DECR_WRAP:
 125       fop = STENCILOP_DECR;
 126       break;
 127    case GL_INVERT:
 128       fop = STENCILOP_INVERT;
 129       break;
 130    default:
 131       break;
 132    }
 133    switch(zfail) {
 134    case GL_KEEP:
 135       dfop = STENCILOP_KEEP;
 136       break;
 137    case GL_ZERO:
 138       dfop = STENCILOP_ZERO;
 139       break;
 140    case GL_REPLACE:
 141       dfop = STENCILOP_REPLACE;
 142       break;
 143    case GL_INCR:
 144       dfop = STENCILOP_INCRSAT;
 145       break;
 146    case GL_DECR:
 147       dfop = STENCILOP_DECRSAT;
 148       break;
 149    case GL_INCR_WRAP:
 150       dfop = STENCILOP_INCR;
 151       break;
 152    case GL_DECR_WRAP:
 153       dfop = STENCILOP_DECR;
 154       break;
 155    case GL_INVERT:
 156       dfop = STENCILOP_INVERT;
 157       break;
 158    default:
 159       break;
 160    }
 161    switch(zpass) {
 162    case GL_KEEP:
 163       dpop = STENCILOP_KEEP;
 164       break;
 165    case GL_ZERO:
 166       dpop = STENCILOP_ZERO;
 167       break;
 168    case GL_REPLACE:
 169       dpop = STENCILOP_REPLACE;
 170       break;
 171    case GL_INCR:
 172       dpop = STENCILOP_INCRSAT;
 173       break;
 174    case GL_DECR:
 175       dpop = STENCILOP_DECRSAT;
 176       break;
 177    case GL_INCR_WRAP:
 178       dpop = STENCILOP_INCR;
 179       break;
 180    case GL_DECR_WRAP:
 181       dpop = STENCILOP_DECR;
 182       break;
 183    case GL_INVERT:
 184       dpop = STENCILOP_INVERT;
 185       break;
 186    default:
 187       break;
 188    }
 189
 190
 191    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 192    i830->state.Ctx[I830_CTXREG_STENCILTST] &= ~(STENCIL_OPS_MASK);
 193    i830->state.Ctx[I830_CTXREG_STENCILTST] |= (ENABLE_STENCIL_PARMS |
 194                                             STENCIL_FAIL_OP(fop) |
 195                                             STENCIL_PASS_DEPTH_FAIL_OP(dfop) |
 196                                             STENCIL_PASS_DEPTH_PASS_OP(dpop));
 197 }
 198
 199 static void i830AlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
 200 {
 201    i830ContextPtr i830 = I830_CONTEXT(ctx);
 202    int test = 0;
 203    GLubyte refByte;
 204    GLuint refInt;
 205
 206    UNCLAMPED_FLOAT_TO_UBYTE(refByte, ref);
 207    refInt = (GLuint)refByte;
 208
 209    switch(func) {
 210    case GL_NEVER:
 211       test = COMPAREFUNC_NEVER;
 212       break;
 213    case GL_LESS:
 214       test = COMPAREFUNC_LESS;
 215       break;
 216    case GL_LEQUAL:
 217       test = COMPAREFUNC_LEQUAL;
 218       break;
 219    case GL_GREATER:
 220       test = COMPAREFUNC_GREATER;
 221       break;
 222    case GL_GEQUAL:
 223       test = COMPAREFUNC_GEQUAL;
 224       break;
 225    case GL_NOTEQUAL:
 226       test = COMPAREFUNC_NOTEQUAL;
 227       break;
 228    case GL_EQUAL:
 229       test = COMPAREFUNC_EQUAL;
 230       break;
 231    case GL_ALWAYS:
 232       test = COMPAREFUNC_ALWAYS;
 233       break;
 234    default:
 235       return;
 236    }
 237
 238    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 239    i830->state.Ctx[I830_CTXREG_STATE2] &= ~ALPHA_TEST_REF_MASK;
 240    i830->state.Ctx[I830_CTXREG_STATE2] |= (ENABLE_ALPHA_TEST_FUNC |
 241                                         ENABLE_ALPHA_REF_VALUE |
 242                                         ALPHA_TEST_FUNC(test) |
 243                                         ALPHA_REF_VALUE(refInt));
 244 }
 245
 246 /* This function makes sure that the proper enables are
 247  * set for LogicOp, Independant Alpha Blend, and Blending.
 248  * It needs to be called from numerous places where we
 249  * could change the LogicOp or Independant Alpha Blend without subsequent
 250  * calls to glEnable.
 251  */
 252 static void i830EvalLogicOpBlendState(GLcontext *ctx)
 253 {
 254    i830ContextPtr i830 = I830_CONTEXT(ctx);
 255
 256    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 257
 258    if (ctx->Color._LogicOpEnabled) {
 259       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~(ENABLE_COLOR_BLEND |
 260                                                ENABLE_LOGIC_OP_MASK);
 261       i830->state.Ctx[I830_CTXREG_ENABLES_1] |= (DISABLE_COLOR_BLEND |
 262                                               ENABLE_LOGIC_OP);
 263    } else if (ctx->Color.BlendEnabled) {
 264       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~(ENABLE_COLOR_BLEND |
 265                                                ENABLE_LOGIC_OP_MASK);
 266       i830->state.Ctx[I830_CTXREG_ENABLES_1] |= (ENABLE_COLOR_BLEND |
 267                                               DISABLE_LOGIC_OP);
 268    } else {
 269       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~(ENABLE_COLOR_BLEND |
 270                                                ENABLE_LOGIC_OP_MASK);
 271       i830->state.Ctx[I830_CTXREG_ENABLES_1] |= (DISABLE_COLOR_BLEND |
 272                                               DISABLE_LOGIC_OP);
 273    }
 274 }
 275
 276 static void i830BlendColor(GLcontext *ctx, const GLfloat color[4])
 277 {
 278    i830ContextPtr i830 = I830_CONTEXT(ctx);
 279    GLubyte r, g, b, a;
 280
 281    if (INTEL_DEBUG&DEBUG_DRI)
 282       fprintf(stderr, "%s\n", __FUNCTION__);
 283
 284    UNCLAMPED_FLOAT_TO_UBYTE(r, color[RCOMP]);
 285    UNCLAMPED_FLOAT_TO_UBYTE(g, color[GCOMP]);
 286    UNCLAMPED_FLOAT_TO_UBYTE(b, color[BCOMP]);
 287    UNCLAMPED_FLOAT_TO_UBYTE(a, color[ACOMP]);
 288
 289    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 290    i830->state.Ctx[I830_CTXREG_BLENDCOLOR1] = (a<<24) | (r<<16) | (g<<8) | b;
 291 }
 292
 293 static void i830BlendEquationSeparate(GLcontext *ctx, GLenum modeRGB,
 294                                       GLenum modeA)
 295 {
 296    i830ContextPtr i830 = I830_CONTEXT(ctx);
 297    int func = ENABLE_ALPHA_BLENDFUNC;
 298
 299    assert( modeRGB == modeA );
 300
 301    if (INTEL_DEBUG&DEBUG_DRI)
 302      fprintf(stderr, "%s %s\n", __FUNCTION__,
 303              _mesa_lookup_enum_by_nr(modeRGB));
 304
 305    /* This will catch a logicop blend equation */
 306    i830EvalLogicOpBlendState(ctx);
 307
 308    switch(modeRGB) {
 309    case GL_FUNC_ADD:
 310       func |= BLENDFUNC_ADD;
 311       break;
 312    case GL_MIN:
 313       func |= BLENDFUNC_MIN;
 314       break;
 315    case GL_MAX:
 316       func |= BLENDFUNC_MAX;
 317       break;
 318    case GL_FUNC_SUBTRACT:
 319       func |= BLENDFUNC_SUB;
 320       break;
 321    case GL_FUNC_REVERSE_SUBTRACT:
 322       func |= BLENDFUNC_RVRSE_SUB;
 323       break;
 324    case GL_LOGIC_OP:
 325    default: return;
 326    }
 327
 328    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 329    i830->state.Ctx[I830_CTXREG_STATE1] &= ~BLENDFUNC_MASK;
 330    i830->state.Ctx[I830_CTXREG_STATE1] |= func;
 331 }
 332
 333
 334
 335 static int translate_blend_factor( GLenum factor )
 336 {
 337    switch(factor) {
 338    case GL_ZERO:
 339       return BLENDFACT_ZERO;
 340    case GL_SRC_ALPHA:
 341       return BLENDFACT_SRC_ALPHA;
 342    case GL_ONE:
 343       return BLENDFACT_ONE;
 344    case GL_SRC_COLOR:
 345       return BLENDFACT_SRC_COLR;
 346    case GL_ONE_MINUS_SRC_COLOR:
 347       return BLENDFACT_INV_SRC_COLR;
 348    case GL_DST_COLOR:
 349       return BLENDFACT_DST_COLR;
 350    case GL_ONE_MINUS_DST_COLOR:
 351       return BLENDFACT_INV_DST_COLR;
 352    case GL_ONE_MINUS_SRC_ALPHA:
 353       return BLENDFACT_INV_SRC_ALPHA;
 354    case GL_DST_ALPHA:
 355       return BLENDFACT_DST_ALPHA;
 356    case GL_ONE_MINUS_DST_ALPHA:
 357       return BLENDFACT_INV_DST_ALPHA;
 358    case GL_SRC_ALPHA_SATURATE:
 359       return BLENDFACT_SRC_ALPHA_SATURATE;
 360    case GL_CONSTANT_COLOR:
 361       return BLENDFACT_CONST_COLOR;
 362    case GL_ONE_MINUS_CONSTANT_COLOR:
 363       return BLENDFACT_INV_CONST_COLOR;
 364    case GL_CONSTANT_ALPHA:
 365       return BLENDFACT_CONST_ALPHA;
 366    case GL_ONE_MINUS_CONSTANT_ALPHA:
 367       return BLENDFACT_INV_CONST_ALPHA;
 368    default:
 369       return BLENDFACT_ZERO;
 370    }
 371 }
 372
 373 static void i830BlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB,
 374                                   GLenum dfactorRGB, GLenum sfactorA,
 375                                   GLenum dfactorA )
 376 {
 377    i830ContextPtr i830 = I830_CONTEXT(ctx);
 378    int iab = i830->state.Ctx[I830_CTXREG_IALPHAB];
 379    int s1 = i830->state.Ctx[I830_CTXREG_STATE1];
 380
 381    if (INTEL_DEBUG&DEBUG_DRI)
 382       fprintf(stderr, "%s\n", __FUNCTION__);
 383
 384
 385    iab &= ~(SRC_DST_ABLEND_MASK|ENABLE_INDPT_ALPHA_BLEND);
 386    s1 &= ~SRC_DST_BLND_MASK;
 387
 388    iab |= (ENABLE_SRC_ABLEND_FACTOR|ENABLE_DST_ABLEND_FACTOR);
 389    s1 |= (ENABLE_SRC_BLND_FACTOR|ENABLE_DST_BLND_FACTOR);
 390
 391    if (ctx->Color.BlendEquationRGB == GL_MIN ||
 392        ctx->Color.BlendEquationRGB == GL_MAX) {
 393       sfactorA = sfactorRGB = dfactorA = dfactorRGB = GL_ONE;
 394    }
 395
 396    iab |= SRC_ABLEND_FACT(translate_blend_factor(sfactorA));
 397    iab |= DST_ABLEND_FACT(translate_blend_factor(dfactorA));
 398    s1 |= SRC_BLND_FACT(translate_blend_factor(sfactorRGB));
 399    s1 |= DST_BLND_FACT(translate_blend_factor(dfactorRGB));
 400
 401    if (sfactorA != sfactorRGB || dfactorA != dfactorRGB)
 402       iab |= ENABLE_INDPT_ALPHA_BLEND;
 403    else
 404       iab |= DISABLE_INDPT_ALPHA_BLEND;
 405
 406    if (iab != i830->state.Ctx[I830_CTXREG_IALPHAB] ||
 407        s1 != i830->state.Ctx[I830_CTXREG_STATE1]) {
 408       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 409       i830->state.Ctx[I830_CTXREG_IALPHAB] = iab;
 410       i830->state.Ctx[I830_CTXREG_STATE1] = s1;
 411    }
 412 }
 413
 414
 415
 416 static void i830DepthFunc(GLcontext *ctx, GLenum func)
 417 {
 418    i830ContextPtr i830 = I830_CONTEXT(ctx);
 419    int test = 0;
 420
 421    if (INTEL_DEBUG&DEBUG_DRI)
 422       fprintf(stderr, "%s\n", __FUNCTION__);
 423
 424    switch(func) {
 425    case GL_NEVER:
 426       test = COMPAREFUNC_NEVER;
 427       break;
 428    case GL_LESS:
 429       test = COMPAREFUNC_LESS;
 430       break;
 431    case GL_LEQUAL:
 432       test = COMPAREFUNC_LEQUAL;
 433       break;
 434    case GL_GREATER:
 435       test = COMPAREFUNC_GREATER;
 436       break;
 437    case GL_GEQUAL:
 438       test = COMPAREFUNC_GEQUAL;
 439       break;
 440    case GL_NOTEQUAL:
 441       test = COMPAREFUNC_NOTEQUAL;
 442       break;
 443    case GL_EQUAL:
 444       test = COMPAREFUNC_EQUAL;
 445       break;
 446    case GL_ALWAYS:
 447       test = COMPAREFUNC_ALWAYS;
 448       break;
 449    default: return;
 450    }
 451
 452    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 453    i830->state.Ctx[I830_CTXREG_STATE3] &= ~DEPTH_TEST_FUNC_MASK;
 454    i830->state.Ctx[I830_CTXREG_STATE3] |= (ENABLE_DEPTH_TEST_FUNC |
 455                                        DEPTH_TEST_FUNC(test));
 456 }
 457
 458 static void i830DepthMask(GLcontext *ctx, GLboolean flag)
 459 {
 460    i830ContextPtr i830 = I830_CONTEXT(ctx);
 461
 462    if (INTEL_DEBUG&DEBUG_DRI)
 463       fprintf(stderr, "%s flag (%d)\n", __FUNCTION__, flag);
 464
 465    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 466
 467    i830->state.Ctx[I830_CTXREG_ENABLES_2] &= ~ENABLE_DIS_DEPTH_WRITE_MASK;
 468
 469    if (flag && ctx->Depth.Test)
 470       i830->state.Ctx[I830_CTXREG_ENABLES_2] |= ENABLE_DEPTH_WRITE;
 471    else
 472       i830->state.Ctx[I830_CTXREG_ENABLES_2] |= DISABLE_DEPTH_WRITE;
 473 }
 474
 475 /* =============================================================
 476  * Polygon stipple
 477  *
 478  * The i830 supports a 4x4 stipple natively, GL wants 32x32.
 479  * Fortunately stipple is usually a repeating pattern.
 480  */
 481 static void i830PolygonStipple( GLcontext *ctx, const GLubyte *mask )
 482 {
 483    i830ContextPtr i830 = I830_CONTEXT(ctx);
 484    const GLubyte *m = mask;
 485    GLubyte p[4];
 486    int i,j,k;
 487    int active = (ctx->Polygon.StippleFlag &&
 488                  i830->intel.reduced_primitive == GL_TRIANGLES);
 489    GLuint newMask;
 490
 491    if (active) {
 492       I830_STATECHANGE(i830, I830_UPLOAD_STIPPLE);
 493       i830->state.Stipple[I830_STPREG_ST1] &= ~ST1_ENABLE;
 494    }
 495
 496    p[0] = mask[12] & 0xf; p[0] |= p[0] << 4;
 497    p[1] = mask[8] & 0xf; p[1] |= p[1] << 4;
 498    p[2] = mask[4] & 0xf; p[2] |= p[2] << 4;
 499    p[3] = mask[0] & 0xf; p[3] |= p[3] << 4;
 500
 501    for (k = 0 ; k < 8 ; k++)
 502       for (j = 3 ; j >= 0; j--)
 503          for (i = 0 ; i < 4 ; i++, m++)
 504             if (*m != p[j]) {
 505                i830->intel.hw_stipple = 0;
 506                return;
 507             }
 508
 509    newMask = (((p[0] & 0xf) << 0) |
 510               ((p[1] & 0xf) << 4) |
 511               ((p[2] & 0xf) << 8) |
 512               ((p[3] & 0xf) << 12));
 513
 514
 515    if (newMask == 0xffff || newMask == 0x0) {
 516       /* this is needed to make conform pass */
 517       i830->intel.hw_stipple = 0;
 518       return;
 519    }
 520
 521    i830->state.Stipple[I830_STPREG_ST1] &= ~0xffff;
 522    i830->state.Stipple[I830_STPREG_ST1] |= newMask;
 523    i830->intel.hw_stipple = 1;
 524
 525    if (active)
 526       i830->state.Stipple[I830_STPREG_ST1] |= ST1_ENABLE;
 527 }
 528
 529
 530 /* =============================================================
 531  * Hardware clipping
 532  */
 533 static void i830Scissor(GLcontext *ctx, GLint x, GLint y,
 534                         GLsizei w, GLsizei h)
 535 {
 536    i830ContextPtr i830 = I830_CONTEXT(ctx);
 537    intelScreenPrivate *screen = i830->intel.intelScreen;
 538    int x1, y1, x2, y2;
 539
 540    if (!i830->intel.driDrawable)
 541       return;
 542
 543    x1 = x;
 544    y1 = i830->intel.driDrawable->h - (y + h);
 545    x2 = x + w - 1;
 546    y2 = y1 + h - 1;
 547
 548    if (INTEL_DEBUG&DEBUG_DRI)
 549       fprintf(stderr, "[%s] x(%d) y(%d) w(%d) h(%d)\n", __FUNCTION__,
 550               x, y, w, h);
 551
 552    if (x1 < 0) x1 = 0;
 553    if (y1 < 0) y1 = 0;
 554    if (x2 < 0) x2 = 0;
 555    if (y2 < 0) y2 = 0;
 556
 557    if (x2 >= screen->width) x2 = screen->width-1;
 558    if (y2 >= screen->height) y2 = screen->height-1;
 559    if (x1 >= screen->width) x1 = screen->width-1;
 560    if (y1 >= screen->height) y1 = screen->height-1;
 561
 562
 563    I830_STATECHANGE(i830, I830_UPLOAD_BUFFERS);
 564    i830->state.Buffer[I830_DESTREG_SR1] = (y1 << 16) | (x1 & 0xffff);
 565    i830->state.Buffer[I830_DESTREG_SR2] = (y2 << 16) | (x2 & 0xffff);
 566 }
 567
 568 static void i830LogicOp(GLcontext *ctx, GLenum opcode)
 569 {
 570    i830ContextPtr i830 = I830_CONTEXT(ctx);
 571    int tmp = 0;
 572
 573    if (INTEL_DEBUG&DEBUG_DRI)
 574       fprintf(stderr, "%s\n", __FUNCTION__);
 575
 576    /* FIXME: This should be a look-up table, like the r200 driver. */
 577    switch(opcode) {
 578    case GL_CLEAR:
 579       tmp = LOGICOP_CLEAR;
 580       break;
 581    case GL_AND:
 582       tmp = LOGICOP_AND;
 583       break;
 584    case GL_AND_REVERSE:
 585       tmp = LOGICOP_AND_RVRSE;
 586       break;
 587    case GL_COPY:
 588       tmp = LOGICOP_COPY;
 589       break;
 590    case GL_COPY_INVERTED:
 591       tmp = LOGICOP_COPY_INV;
 592       break;
 593    case GL_AND_INVERTED:
 594       tmp = LOGICOP_AND_INV;
 595       break;
 596    case GL_NOOP:
 597       tmp = LOGICOP_NOOP;
 598       break;
 599    case GL_XOR:
 600       tmp = LOGICOP_XOR;
 601       break;
 602    case GL_OR:
 603       tmp = LOGICOP_OR;
 604       break;
 605    case GL_OR_INVERTED:
 606       tmp = LOGICOP_OR_INV;
 607       break;
 608    case GL_NOR:
 609       tmp = LOGICOP_NOR;
 610       break;
 611    case GL_EQUIV:
 612       tmp = LOGICOP_EQUIV;
 613       break;
 614    case GL_INVERT:
 615       tmp = LOGICOP_INV;
 616       break;
 617    case GL_OR_REVERSE:
 618       tmp = LOGICOP_OR_RVRSE;
 619       break;
 620    case GL_NAND:
 621       tmp = LOGICOP_NAND;
 622       break;
 623    case GL_SET:
 624       tmp = LOGICOP_SET;
 625       break;
 626    default:
 627       return;
 628    }
 629
 630    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 631    i830->state.Ctx[I830_CTXREG_STATE4] &= ~LOGICOP_MASK;
 632    i830->state.Ctx[I830_CTXREG_STATE4] |= LOGIC_OP_FUNC(tmp);
 633 }
 634
 635
 636
 637 static void i830CullFaceFrontFace(GLcontext *ctx, GLenum unused)
 638 {
 639    i830ContextPtr i830 = I830_CONTEXT(ctx);
 640    GLuint mode;
 641
 642    if (INTEL_DEBUG&DEBUG_DRI)
 643       fprintf(stderr, "%s\n", __FUNCTION__);
 644
 645    if (!ctx->Polygon.CullFlag) {
 646       mode = CULLMODE_NONE;
 647    }
 648    else if (ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) {
 649       mode = CULLMODE_CW;
 650
 651       if (ctx->Polygon.CullFaceMode == GL_FRONT)
 652          mode ^= (CULLMODE_CW ^ CULLMODE_CCW);
 653       if (ctx->Polygon.FrontFace != GL_CCW)
 654          mode ^= (CULLMODE_CW ^ CULLMODE_CCW);
 655    }
 656    else {
 657       mode = CULLMODE_BOTH;
 658    }
 659
 660    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 661    i830->state.Ctx[I830_CTXREG_STATE3] &= ~CULLMODE_MASK;
 662    i830->state.Ctx[I830_CTXREG_STATE3] |= ENABLE_CULL_MODE | mode;
 663 }
 664
 665 static void i830LineWidth( GLcontext *ctx, GLfloat widthf )
 666 {
 667    i830ContextPtr i830 = I830_CONTEXT( ctx );
 668    int width;
 669    int state5;
 670
 671    if (INTEL_DEBUG&DEBUG_DRI)
 672       fprintf(stderr, "%s\n", __FUNCTION__);
 673
 674    width = (int)(widthf * 2);
 675    CLAMP_SELF(width, 1, 15);
 676
 677    state5 = i830->state.Ctx[I830_CTXREG_STATE5] & ~FIXED_LINE_WIDTH_MASK;
 678    state5 |= (ENABLE_FIXED_LINE_WIDTH | FIXED_LINE_WIDTH(width));
 679
 680    if (state5 != i830->state.Ctx[I830_CTXREG_STATE5]) {
 681       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 682       i830->state.Ctx[I830_CTXREG_STATE5] = state5;
 683    }
 684 }
 685
 686 static void i830PointSize(GLcontext *ctx, GLfloat size)
 687 {
 688    i830ContextPtr i830 = I830_CONTEXT(ctx);
 689    GLint point_size = (int)size;
 690
 691    if (INTEL_DEBUG&DEBUG_DRI)
 692      fprintf(stderr, "%s\n", __FUNCTION__);
 693
 694    CLAMP_SELF(point_size, 1, 256);
 695    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 696    i830->state.Ctx[I830_CTXREG_STATE5] &= ~FIXED_POINT_WIDTH_MASK;
 697    i830->state.Ctx[I830_CTXREG_STATE5] |= (ENABLE_FIXED_POINT_WIDTH |
 698                                        FIXED_POINT_WIDTH(point_size));
 699 }
 700
 701
 702 /* =============================================================
 703  * Color masks
 704  */
 705
 706 static void i830ColorMask(GLcontext *ctx,
 707                           GLboolean r, GLboolean g,
 708                           GLboolean b, GLboolean a)
 709 {
 710    i830ContextPtr i830 = I830_CONTEXT( ctx );
 711    GLuint tmp = 0;
 712
 713    if (INTEL_DEBUG&DEBUG_DRI)
 714       fprintf(stderr, "%s r(%d) g(%d) b(%d) a(%d)\n", __FUNCTION__, r, g, b, a);
 715
 716    tmp = ((i830->state.Ctx[I830_CTXREG_ENABLES_2] & ~WRITEMASK_MASK) |
 717           ENABLE_COLOR_MASK |
 718           ENABLE_COLOR_WRITE |
 719           ((!r) << WRITEMASK_RED_SHIFT) |
 720           ((!g) << WRITEMASK_GREEN_SHIFT) |
 721           ((!b) << WRITEMASK_BLUE_SHIFT) |
 722           ((!a) << WRITEMASK_ALPHA_SHIFT));
 723
 724    if (tmp != i830->state.Ctx[I830_CTXREG_ENABLES_2]) {
 725       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 726       i830->state.Ctx[I830_CTXREG_ENABLES_2] = tmp;
 727    }
 728 }
 729
 730 static void update_specular( GLcontext *ctx )
 731 {
 732    i830ContextPtr i830 = I830_CONTEXT( ctx );
 733
 734    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 735    i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~ENABLE_SPEC_ADD_MASK;
 736
 737    if (NEED_SECONDARY_COLOR(ctx))
 738       i830->state.Ctx[I830_CTXREG_ENABLES_1] |= ENABLE_SPEC_ADD;
 739    else
 740       i830->state.Ctx[I830_CTXREG_ENABLES_1] |= DISABLE_SPEC_ADD;
 741 }
 742
 743 static void i830LightModelfv(GLcontext *ctx, GLenum pname,
 744                              const GLfloat *param)
 745 {
 746    if (INTEL_DEBUG&DEBUG_DRI)
 747       fprintf(stderr, "%s\n", __FUNCTION__);
 748
 749    if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
 750       update_specular( ctx );
 751    }
 752 }
 753
 754 /* In Mesa 3.5 we can reliably do native flatshading.
 755  */
 756 static void i830ShadeModel(GLcontext *ctx, GLenum mode)
 757 {
 758    i830ContextPtr i830 = I830_CONTEXT(ctx);
 759    I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 760
 761
 762 #define SHADE_MODE_MASK ((1<<10)|(1<<8)|(1<<6)|(1<<4))
 763
 764    i830->state.Ctx[I830_CTXREG_STATE3] &= ~SHADE_MODE_MASK;
 765
 766    if (mode == GL_FLAT) {
 767      i830->state.Ctx[I830_CTXREG_STATE3] |= (ALPHA_SHADE_MODE(SHADE_MODE_FLAT) |
 768                                           FOG_SHADE_MODE(SHADE_MODE_FLAT) |
 769                                           SPEC_SHADE_MODE(SHADE_MODE_FLAT) |
 770                                           COLOR_SHADE_MODE(SHADE_MODE_FLAT));
 771    } else {
 772      i830->state.Ctx[I830_CTXREG_STATE3] |= (ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) |
 773                                           FOG_SHADE_MODE(SHADE_MODE_LINEAR) |
 774                                           SPEC_SHADE_MODE(SHADE_MODE_LINEAR) |
 775                                           COLOR_SHADE_MODE(SHADE_MODE_LINEAR));
 776    }
 777 }
 778
 779 /* =============================================================
 780  * Fog
 781  */
 782 static void i830Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
 783 {
 784    i830ContextPtr i830 = I830_CONTEXT(ctx);
 785
 786    if (INTEL_DEBUG&DEBUG_DRI)
 787       fprintf(stderr, "%s\n", __FUNCTION__);
 788
 789    if (pname == GL_FOG_COLOR) {
 790       GLuint color = (((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) |
 791                       ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) |
 792                       ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0));
 793
 794       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 795       i830->state.Ctx[I830_CTXREG_FOGCOLOR] = (_3DSTATE_FOG_COLOR_CMD | color);
 796    }
 797 }
 798
 799 /* =============================================================
 800  */
 801
 802 static void i830Enable(GLcontext *ctx, GLenum cap, GLboolean state)
 803 {
 804    i830ContextPtr i830 = I830_CONTEXT(ctx);
 805
 806    switch(cap) {
 807    case GL_LIGHTING:
 808    case GL_COLOR_SUM:
 809       update_specular( ctx );
 810       break;
 811
 812    case GL_ALPHA_TEST:
 813       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 814       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_ALPHA_TEST_MASK;
 815       if (state)
 816          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= ENABLE_ALPHA_TEST;
 817       else
 818          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= DISABLE_ALPHA_TEST;
 819
 820       break;
 821
 822    case GL_BLEND:
 823       i830EvalLogicOpBlendState(ctx);
 824       break;
 825
 826    case GL_COLOR_LOGIC_OP:
 827       i830EvalLogicOpBlendState(ctx);
 828
 829       /* Logicop doesn't seem to work at 16bpp:
 830        */
 831       if (i830->intel.intelScreen->cpp == 2)
 832          FALLBACK( &i830->intel, I830_FALLBACK_LOGICOP, state );
 833       break;
 834
 835    case GL_DITHER:
 836       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 837       i830->state.Ctx[I830_CTXREG_ENABLES_2] &= ~ENABLE_DITHER;
 838
 839       if (state)
 840          i830->state.Ctx[I830_CTXREG_ENABLES_2] |= ENABLE_DITHER;
 841       else
 842          i830->state.Ctx[I830_CTXREG_ENABLES_2] |= DISABLE_DITHER;
 843       break;
 844
 845    case GL_DEPTH_TEST:
 846       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 847       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_DEPTH_TEST_MASK;
 848
 849       if (state)
 850          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= ENABLE_DEPTH_TEST;
 851       else
 852          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= DISABLE_DEPTH_TEST;
 853
 854       /* Also turn off depth writes when GL_DEPTH_TEST is disabled:
 855        */
 856       i830DepthMask( ctx, ctx->Depth.Mask );
 857       break;
 858
 859    case GL_SCISSOR_TEST:
 860       I830_STATECHANGE(i830, I830_UPLOAD_BUFFERS);
 861
 862       if (state)
 863          i830->state.Buffer[I830_DESTREG_SENABLE] =
 864             (_3DSTATE_SCISSOR_ENABLE_CMD |
 865              ENABLE_SCISSOR_RECT);
 866       else
 867          i830->state.Buffer[I830_DESTREG_SENABLE] =
 868             (_3DSTATE_SCISSOR_ENABLE_CMD |
 869              DISABLE_SCISSOR_RECT);
 870
 871       break;
 872
 873    case GL_LINE_SMOOTH:
 874       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 875
 876       i830->state.Ctx[I830_CTXREG_AA] &= ~AA_LINE_ENABLE;
 877       if (state)
 878          i830->state.Ctx[I830_CTXREG_AA] |= AA_LINE_ENABLE;
 879       else
 880          i830->state.Ctx[I830_CTXREG_AA] |= AA_LINE_DISABLE;
 881       break;
 882
 883    case GL_FOG:
 884       I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 885       i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_FOG_MASK;
 886       if (state)
 887          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= ENABLE_FOG;
 888       else
 889          i830->state.Ctx[I830_CTXREG_ENABLES_1] |= DISABLE_FOG;
 890       break;
 891
 892    case GL_CULL_FACE:
 893       i830CullFaceFrontFace(ctx, 0);
 894       break;
 895
 896    case GL_TEXTURE_2D:
 897       break;
 898
 899    case GL_STENCIL_TEST:
 900       if (i830->intel.hw_stencil) {
 901          I830_STATECHANGE(i830, I830_UPLOAD_CTX);
 902
 903          if (state) {
 904             i830->state.Ctx[I830_CTXREG_ENABLES_1] |= ENABLE_STENCIL_TEST;
 905             i830->state.Ctx[I830_CTXREG_ENABLES_2] |= ENABLE_STENCIL_WRITE;
 906          } else {
 907             i830->state.Ctx[I830_CTXREG_ENABLES_1] &= ~ENABLE_STENCIL_TEST;
 908             i830->state.Ctx[I830_CTXREG_ENABLES_2] &= ~ENABLE_STENCIL_WRITE;
 909             i830->state.Ctx[I830_CTXREG_ENABLES_1] |= DISABLE_STENCIL_TEST;
 910             i830->state.Ctx[I830_CTXREG_ENABLES_2] |= DISABLE_STENCIL_WRITE;
 911          }
 912       } else {
 913          FALLBACK( &i830->intel, I830_FALLBACK_STENCIL, state );
 914       }
 915       break;
 916
 917    case GL_POLYGON_STIPPLE:
 918       /* The stipple command worked on my 855GM box, but not my 845G.
 919        * I'll do more testing later to find out exactly which hardware
 920        * supports it.  Disabled for now.
 921        */
 922       if (i830->intel.hw_stipple &&
 923           i830->intel.reduced_primitive == GL_TRIANGLES)
 924       {
 925          I830_STATECHANGE(i830, I830_UPLOAD_STIPPLE);
 926          i830->state.Stipple[I830_STPREG_ST1] &= ~ST1_ENABLE;
 927          if (state)
 928             i830->state.Stipple[I830_STPREG_ST1] |= ST1_ENABLE;
 929       }
 930       break;
 931
 932    default:
 933       ;
 934    }
 935 }
 936
 937
 938 static void i830_init_packets( i830ContextPtr i830 )
 939 {
 940    intelScreenPrivate *screen = i830->intel.intelScreen;
 941
 942    /* Zero all state */
 943    memset(&i830->state, 0, sizeof(i830->state));
 944
 945    /* Set default blend state */
 946    i830->state.TexBlend[0][0] = (_3DSTATE_MAP_BLEND_OP_CMD(0) |
 947                                   TEXPIPE_COLOR |
 948                                   ENABLE_TEXOUTPUT_WRT_SEL |
 949                                   TEXOP_OUTPUT_CURRENT |
 950                                   DISABLE_TEX_CNTRL_STAGE |
 951                                   TEXOP_SCALE_1X |
 952                                   TEXOP_MODIFY_PARMS |
 953                                   TEXOP_LAST_STAGE |
 954                                   TEXBLENDOP_ARG1);
 955    i830->state.TexBlend[0][1] = (_3DSTATE_MAP_BLEND_OP_CMD(0) |
 956                                   TEXPIPE_ALPHA |
 957                                   ENABLE_TEXOUTPUT_WRT_SEL |
 958                                   TEXOP_OUTPUT_CURRENT |
 959                                   TEXOP_SCALE_1X |
 960                                   TEXOP_MODIFY_PARMS |
 961                                   TEXBLENDOP_ARG1);
 962    i830->state.TexBlend[0][2] = (_3DSTATE_MAP_BLEND_ARG_CMD(0) |
 963                                   TEXPIPE_COLOR |
 964                                   TEXBLEND_ARG1 |
 965                                   TEXBLENDARG_MODIFY_PARMS |
 966                                   TEXBLENDARG_DIFFUSE);
 967    i830->state.TexBlend[0][3] = (_3DSTATE_MAP_BLEND_ARG_CMD(0) |
 968                                   TEXPIPE_ALPHA |
 969                                   TEXBLEND_ARG1 |
 970                                   TEXBLENDARG_MODIFY_PARMS |
 971                                   TEXBLENDARG_DIFFUSE);
 972
 973    i830->state.TexBlendWordsUsed[0] = 4;
 974
 975
 976    i830->state.Ctx[I830_CTXREG_VF] =  0;
 977    i830->state.Ctx[I830_CTXREG_VF2] = 0;
 978
 979    i830->state.Ctx[I830_CTXREG_AA] = (_3DSTATE_AA_CMD |
 980                                       AA_LINE_ECAAR_WIDTH_ENABLE |
 981                                       AA_LINE_ECAAR_WIDTH_1_0 |
 982                                       AA_LINE_REGION_WIDTH_ENABLE |
 983                                       AA_LINE_REGION_WIDTH_1_0 |
 984                                       AA_LINE_DISABLE);
 985
 986    i830->state.Ctx[I830_CTXREG_ENABLES_1] = (_3DSTATE_ENABLES_1_CMD |
 987                                              DISABLE_LOGIC_OP |
 988                                              DISABLE_STENCIL_TEST |
 989                                              DISABLE_DEPTH_BIAS |
 990                                              DISABLE_SPEC_ADD |
 991                                              DISABLE_FOG |
 992                                              DISABLE_ALPHA_TEST |
 993                                              DISABLE_COLOR_BLEND |
 994                                              DISABLE_DEPTH_TEST);
 995
 996    if (i830->intel.hw_stencil) {
 997       i830->state.Ctx[I830_CTXREG_ENABLES_2] = (_3DSTATE_ENABLES_2_CMD |
 998                                                 ENABLE_STENCIL_WRITE |
 999                                                 ENABLE_TEX_CACHE |
1000                                                 ENABLE_DITHER |
1001                                                 ENABLE_COLOR_MASK |
1002                                                 /* set no color comps disabled */
1003                                                 ENABLE_COLOR_WRITE |
1004                                                 ENABLE_DEPTH_WRITE);
1005    } else {
1006       i830->state.Ctx[I830_CTXREG_ENABLES_2] = (_3DSTATE_ENABLES_2_CMD |
1007                                                 DISABLE_STENCIL_WRITE |
1008                                                 ENABLE_TEX_CACHE |
1009                                                 ENABLE_DITHER |
1010                                                 ENABLE_COLOR_MASK |
1011                                                 /* set no color comps disabled */
1012                                                 ENABLE_COLOR_WRITE |
1013                                                 ENABLE_DEPTH_WRITE);
1014    }
1015
1016    i830->state.Ctx[I830_CTXREG_STATE1] = (_3DSTATE_MODES_1_CMD |
1017                                           ENABLE_COLR_BLND_FUNC |
1018                                           BLENDFUNC_ADD |
1019                                           ENABLE_SRC_BLND_FACTOR |
1020                                           SRC_BLND_FACT(BLENDFACT_ONE) |
1021                                           ENABLE_DST_BLND_FACTOR |
1022                                           DST_BLND_FACT(BLENDFACT_ZERO) );
1023
1024    i830->state.Ctx[I830_CTXREG_STATE2] = (_3DSTATE_MODES_2_CMD |
1025                                           ENABLE_GLOBAL_DEPTH_BIAS |
1026                                           GLOBAL_DEPTH_BIAS(0) |
1027                                           ENABLE_ALPHA_TEST_FUNC |
1028                                           ALPHA_TEST_FUNC(COMPAREFUNC_ALWAYS) |
1029                                           ALPHA_REF_VALUE(0) );
1030
1031    i830->state.Ctx[I830_CTXREG_STATE3] = (_3DSTATE_MODES_3_CMD |
1032                                           ENABLE_DEPTH_TEST_FUNC |
1033                                           DEPTH_TEST_FUNC(COMPAREFUNC_LESS) |
1034                                           ENABLE_ALPHA_SHADE_MODE |
1035                                           ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) |
1036                                           ENABLE_FOG_SHADE_MODE |
1037                                           FOG_SHADE_MODE(SHADE_MODE_LINEAR) |
1038                                           ENABLE_SPEC_SHADE_MODE |
1039                                           SPEC_SHADE_MODE(SHADE_MODE_LINEAR) |
1040                                           ENABLE_COLOR_SHADE_MODE |
1041                                           COLOR_SHADE_MODE(SHADE_MODE_LINEAR) |
1042                                           ENABLE_CULL_MODE |
1043                                           CULLMODE_NONE);
1044
1045    i830->state.Ctx[I830_CTXREG_STATE4] = (_3DSTATE_MODES_4_CMD |
1046                                           ENABLE_LOGIC_OP_FUNC |
1047                                           LOGIC_OP_FUNC(LOGICOP_COPY) |
1048                                           ENABLE_STENCIL_TEST_MASK |
1049                                           STENCIL_TEST_MASK(0xff) |
1050                                           ENABLE_STENCIL_WRITE_MASK |
1051                                           STENCIL_WRITE_MASK(0xff));
1052
1053    i830->state.Ctx[I830_CTXREG_STENCILTST] = (_3DSTATE_STENCIL_TEST_CMD |
1054                                               ENABLE_STENCIL_PARMS |
1055                                               STENCIL_FAIL_OP(STENCILOP_KEEP) |
1056                                               STENCIL_PASS_DEPTH_FAIL_OP(STENCILOP_KEEP) |
1057                                               STENCIL_PASS_DEPTH_PASS_OP(STENCILOP_KEEP) |
1058                                               ENABLE_STENCIL_TEST_FUNC |
1059                                               STENCIL_TEST_FUNC(COMPAREFUNC_ALWAYS) |
1060                                               ENABLE_STENCIL_REF_VALUE |
1061                                               STENCIL_REF_VALUE(0) );
1062
1063    i830->state.Ctx[I830_CTXREG_STATE5] = (_3DSTATE_MODES_5_CMD |
1064                                           FLUSH_TEXTURE_CACHE |
1065                                           ENABLE_SPRITE_POINT_TEX |
1066                                           SPRITE_POINT_TEX_OFF |
1067                                           ENABLE_FIXED_LINE_WIDTH |
1068                                           FIXED_LINE_WIDTH(0x2) | /* 1.0 */
1069                                           ENABLE_FIXED_POINT_WIDTH |
1070                                           FIXED_POINT_WIDTH(1) );
1071
1072    i830->state.Ctx[I830_CTXREG_IALPHAB] = (_3DSTATE_INDPT_ALPHA_BLEND_CMD |
1073                                            DISABLE_INDPT_ALPHA_BLEND |
1074                                            ENABLE_ALPHA_BLENDFUNC |
1075                                            ABLENDFUNC_ADD);
1076
1077    i830->state.Ctx[I830_CTXREG_FOGCOLOR] = (_3DSTATE_FOG_COLOR_CMD |
1078                                             FOG_COLOR_RED(0) |
1079                                             FOG_COLOR_GREEN(0) |
1080                                             FOG_COLOR_BLUE(0));
1081
1082    i830->state.Ctx[I830_CTXREG_BLENDCOLOR0] = _3DSTATE_CONST_BLEND_COLOR_CMD;
1083    i830->state.Ctx[I830_CTXREG_BLENDCOLOR1] = 0;
1084
1085    i830->state.Ctx[I830_CTXREG_MCSB0] = _3DSTATE_MAP_COORD_SETBIND_CMD;
1086    i830->state.Ctx[I830_CTXREG_MCSB1] = (TEXBIND_SET3(TEXCOORDSRC_VTXSET_3) |
1087                                          TEXBIND_SET2(TEXCOORDSRC_VTXSET_2) |
1088                                          TEXBIND_SET1(TEXCOORDSRC_VTXSET_1) |
1089                                          TEXBIND_SET0(TEXCOORDSRC_VTXSET_0));
1090
1091
1092    i830->state.Stipple[I830_STPREG_ST0] = _3DSTATE_STIPPLE;
1093
1094    i830->state.Buffer[I830_DESTREG_CBUFADDR0] = _3DSTATE_BUF_INFO_CMD;
1095    i830->state.Buffer[I830_DESTREG_CBUFADDR1] =
1096       (BUF_3D_ID_COLOR_BACK |
1097        BUF_3D_PITCH(screen->frontPitch * screen->cpp) |
1098        BUF_3D_USE_FENCE);
1099
1100
1101    i830->state.Buffer[I830_DESTREG_DBUFADDR0] = _3DSTATE_BUF_INFO_CMD;
1102    i830->state.Buffer[I830_DESTREG_DBUFADDR1] =
1103       (BUF_3D_ID_DEPTH |
1104        BUF_3D_PITCH(screen->depthPitch * screen->cpp) |
1105        BUF_3D_USE_FENCE);
1106    i830->state.Buffer[I830_DESTREG_DBUFADDR2] = screen->depthOffset;
1107
1108
1109    i830->state.Buffer[I830_DESTREG_DV0] = _3DSTATE_DST_BUF_VARS_CMD;
1110
1111    switch (screen->fbFormat) {
1112    case DV_PF_555:
1113    case DV_PF_565:
1114       i830->state.Buffer[I830_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */
1115                                               DSTORG_VERT_BIAS(0x8) | /* .5 */
1116                                               screen->fbFormat |
1117                                               DEPTH_IS_Z |
1118                                               DEPTH_FRMT_16_FIXED);
1119       break;
1120    case DV_PF_8888:
1121       i830->state.Buffer[I830_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */
1122                                               DSTORG_VERT_BIAS(0x8) | /* .5 */
1123                                               screen->fbFormat |
1124                                               DEPTH_IS_Z |
1125                                               DEPTH_FRMT_24_FIXED_8_OTHER);
1126       break;
1127    }
1128
1129    i830->state.Buffer[I830_DESTREG_SENABLE] = (_3DSTATE_SCISSOR_ENABLE_CMD |
1130                                                DISABLE_SCISSOR_RECT);
1131    i830->state.Buffer[I830_DESTREG_SR0] = _3DSTATE_SCISSOR_RECT_0_CMD;
1132    i830->state.Buffer[I830_DESTREG_SR1] = 0;
1133    i830->state.Buffer[I830_DESTREG_SR2] = 0;
1134 }
1135
1136
1137 void i830InitStateFuncs( struct dd_function_table *functions )
1138 {
1139    functions->AlphaFunc = i830AlphaFunc;
1140    functions->BlendColor = i830BlendColor;
1141    functions->BlendEquationSeparate = i830BlendEquationSeparate;
1142    functions->BlendFuncSeparate = i830BlendFuncSeparate;
1143    functions->ColorMask = i830ColorMask;
1144    functions->CullFace = i830CullFaceFrontFace;
1145    functions->DepthFunc = i830DepthFunc;
1146    functions->DepthMask = i830DepthMask;
1147    functions->Enable = i830Enable;
1148    functions->Fogfv = i830Fogfv;
1149    functions->FrontFace = i830CullFaceFrontFace;
1150    functions->LightModelfv = i830LightModelfv;
1151    functions->LineWidth = i830LineWidth;
1152    functions->LogicOpcode = i830LogicOp;
1153    functions->PointSize = i830PointSize;
1154    functions->PolygonStipple = i830PolygonStipple;
1155    functions->Scissor = i830Scissor;
1156    functions->ShadeModel = i830ShadeModel;
1157    functions->StencilFunc = i830StencilFunc;
1158    functions->StencilMask = i830StencilMask;
1159    functions->StencilOp = i830StencilOp;
1160 }
1161
1162 void i830InitState( i830ContextPtr i830 )
1163 {
1164    GLcontext *ctx = &i830->intel.ctx;
1165
1166    i830_init_packets( i830 );
1167
1168    intelInitState( ctx );
1169
1170    memcpy( &i830->initial, &i830->state, sizeof(i830->state) );
1171
1172    i830->current = &i830->state;
1173    i830->state.emitted = 0;
1174    i830->state.active = (I830_UPLOAD_TEXBLEND(0) |
1175                          I830_UPLOAD_STIPPLE |
1176                          I830_UPLOAD_CTX |
1177                          I830_UPLOAD_BUFFERS);
1178 }
1179
1180
1181
1182
1183