src/mesa/drivers/dri/mach64/mach64_state.c

   1 /* -*- mode: c; c-basic-offset: 3 -*- */
   2 /*
   3  * Copyright 2000 Gareth Hughes
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * GARETH HUGHES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /*
  26  * Authors:
  27  *      Gareth Hughes <gareth@valinux.com>
  28  *      Leif Delgass <ldelgass@retinalburn.net>
  29  *      Jos�Fonseca <j_r_fonseca@yahoo.co.uk>
  30  */
  31
  32 #include "mach64_context.h"
  33 #include "mach64_state.h"
  34 #include "mach64_ioctl.h"
  35 #include "mach64_tris.h"
  36 #include "mach64_vb.h"
  37 #include "mach64_tex.h"
  38
  39 #include "main/context.h"
  40 #include "main/enums.h"
  41 #include "main/colormac.h"
  42 #include "swrast/swrast.h"
  43 #include "vbo/vbo.h"
  44 #include "tnl/tnl.h"
  45 #include "swrast_setup/swrast_setup.h"
  46
  47 #include "tnl/t_pipeline.h"
  48
  49
  50 /* =============================================================
  51  * Alpha blending
  52  */
  53
  54 static void mach64UpdateAlphaMode( GLcontext *ctx )
  55 {
  56    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
  57    GLuint a = mmesa->setup.alpha_tst_cntl;
  58    GLuint s = mmesa->setup.scale_3d_cntl;
  59    GLuint m = mmesa->setup.dp_write_mask;
  60
  61    if ( ctx->Color.AlphaEnabled ) {
  62       GLubyte ref;
  63
  64       CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);
  65
  66       a &= ~(MACH64_ALPHA_TEST_MASK | MACH64_REF_ALPHA_MASK);
  67
  68       switch ( ctx->Color.AlphaFunc ) {
  69       case GL_NEVER:
  70          a |= MACH64_ALPHA_TEST_NEVER;
  71          break;
  72       case GL_LESS:
  73          a |= MACH64_ALPHA_TEST_LESS;
  74          break;
  75       case GL_LEQUAL:
  76          a |= MACH64_ALPHA_TEST_LEQUAL;
  77          break;
  78       case GL_EQUAL:
  79          a |= MACH64_ALPHA_TEST_EQUAL;
  80          break;
  81       case GL_GEQUAL:
  82          a |= MACH64_ALPHA_TEST_GEQUAL;
  83          break;
  84       case GL_GREATER:
  85          a |= MACH64_ALPHA_TEST_GREATER;
  86          break;
  87       case GL_NOTEQUAL:
  88          a |= MACH64_ALPHA_TEST_NOTEQUAL;
  89          break;
  90       case GL_ALWAYS:
  91          a |= MACH64_ALPHA_TEST_ALWAYS;
  92          break;
  93       }
  94
  95       a |= (ref << MACH64_REF_ALPHA_SHIFT);
  96       a |=  MACH64_ALPHA_TEST_EN;
  97    } else {
  98       a &= ~MACH64_ALPHA_TEST_EN;
  99    }
 100
 101    FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_FALSE );
 102
 103    if ( ctx->Color.BlendEnabled ) {
 104       s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
 105              MACH64_ALPHA_BLEND_DST_MASK |
 106              MACH64_ALPHA_BLEND_SAT);
 107
 108       switch ( ctx->Color.BlendSrcRGB ) {
 109       case GL_ZERO:
 110          s |= MACH64_ALPHA_BLEND_SRC_ZERO;
 111          break;
 112       case GL_ONE:
 113          s |= MACH64_ALPHA_BLEND_SRC_ONE;
 114          break;
 115       case GL_DST_COLOR:
 116          s |= MACH64_ALPHA_BLEND_SRC_DSTCOLOR;
 117          break;
 118       case GL_ONE_MINUS_DST_COLOR:
 119          s |= MACH64_ALPHA_BLEND_SRC_INVDSTCOLOR;
 120          break;
 121       case GL_SRC_ALPHA:
 122          s |= MACH64_ALPHA_BLEND_SRC_SRCALPHA;
 123          break;
 124       case GL_ONE_MINUS_SRC_ALPHA:
 125          s |= MACH64_ALPHA_BLEND_SRC_INVSRCALPHA;
 126          break;
 127       case GL_DST_ALPHA:
 128          s |= MACH64_ALPHA_BLEND_SRC_DSTALPHA;
 129          break;
 130       case GL_ONE_MINUS_DST_ALPHA:
 131          s |= MACH64_ALPHA_BLEND_SRC_INVDSTALPHA;
 132          break;
 133       case GL_SRC_ALPHA_SATURATE:
 134          s |= (MACH64_ALPHA_BLEND_SRC_SRCALPHA |
 135                MACH64_ALPHA_BLEND_SAT);
 136          break;
 137       default:
 138          FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_TRUE );
 139       }
 140
 141       switch ( ctx->Color.BlendDstRGB ) {
 142       case GL_ZERO:
 143          s |= MACH64_ALPHA_BLEND_DST_ZERO;
 144          break;
 145       case GL_ONE:
 146          s |= MACH64_ALPHA_BLEND_DST_ONE;
 147          break;
 148       case GL_SRC_COLOR:
 149          s |= MACH64_ALPHA_BLEND_DST_SRCCOLOR;
 150          break;
 151       case GL_ONE_MINUS_SRC_COLOR:
 152          s |= MACH64_ALPHA_BLEND_DST_INVSRCCOLOR;
 153          break;
 154       case GL_SRC_ALPHA:
 155          s |= MACH64_ALPHA_BLEND_DST_SRCALPHA;
 156          break;
 157       case GL_ONE_MINUS_SRC_ALPHA:
 158          s |= MACH64_ALPHA_BLEND_DST_INVSRCALPHA;
 159          break;
 160       case GL_DST_ALPHA:
 161          s |= MACH64_ALPHA_BLEND_DST_DSTALPHA;
 162          break;
 163       case GL_ONE_MINUS_DST_ALPHA:
 164          s |= MACH64_ALPHA_BLEND_DST_INVDSTALPHA;
 165          break;
 166       default:
 167          FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_TRUE );
 168       }
 169
 170       m = 0xffffffff; /* Can't color mask and blend at the same time */
 171       s &= ~MACH64_ALPHA_FOG_EN_FOG; /* Can't fog and blend at the same time */
 172       s |=  MACH64_ALPHA_FOG_EN_ALPHA;
 173    } else {
 174       s &= ~MACH64_ALPHA_FOG_EN_ALPHA;
 175    }
 176
 177    if ( mmesa->setup.alpha_tst_cntl != a ) {
 178       mmesa->setup.alpha_tst_cntl = a;
 179       mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
 180    }
 181    if ( mmesa->setup.scale_3d_cntl != s ) {
 182       mmesa->setup.scale_3d_cntl = s;
 183       mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
 184    }
 185    if ( mmesa->setup.dp_write_mask != m ) {
 186       mmesa->setup.dp_write_mask = m;
 187       mmesa->dirty |= MACH64_UPLOAD_DP_WRITE_MASK;
 188    }
 189 }
 190
 191 static void mach64DDAlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
 192 {
 193    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 194
 195    FLUSH_BATCH( mmesa );
 196    mmesa->new_state |= MACH64_NEW_ALPHA;
 197 }
 198
 199 static void mach64DDBlendEquationSeparate( GLcontext *ctx,
 200                                            GLenum modeRGB, GLenum modeA )
 201 {
 202    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 203
 204    assert( modeRGB == modeA );
 205    FLUSH_BATCH( mmesa );
 206
 207    /* BlendEquation affects ColorLogicOpEnabled
 208     */
 209    FALLBACK( MACH64_CONTEXT(ctx), MACH64_FALLBACK_LOGICOP,
 210              (ctx->Color.ColorLogicOpEnabled &&
 211               ctx->Color.LogicOp != GL_COPY));
 212
 213    /* Can only do blend addition, not min, max, subtract, etc. */
 214    FALLBACK( MACH64_CONTEXT(ctx), MACH64_FALLBACK_BLEND_EQ,
 215              modeRGB != GL_FUNC_ADD);
 216
 217    mmesa->new_state |= MACH64_NEW_ALPHA;
 218 }
 219
 220 static void mach64DDBlendFuncSeparate( GLcontext *ctx,
 221                                        GLenum sfactorRGB, GLenum dfactorRGB,
 222                                        GLenum sfactorA, GLenum dfactorA )
 223 {
 224    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 225
 226    FLUSH_BATCH( mmesa );
 227    mmesa->new_state |= MACH64_NEW_ALPHA;
 228 }
 229
 230
 231 /* =============================================================
 232  * Depth testing
 233  */
 234
 235 static void mach64UpdateZMode( GLcontext *ctx )
 236 {
 237    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 238    GLuint z = mmesa->setup.z_cntl;
 239
 240    if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
 241       fprintf( stderr, "%s:\n", __FUNCTION__ );
 242    }
 243
 244    if ( ctx->Depth.Test ) {
 245       z &= ~MACH64_Z_TEST_MASK;
 246
 247       switch ( ctx->Depth.Func ) {
 248       case GL_NEVER:
 249          z |= MACH64_Z_TEST_NEVER;
 250          break;
 251       case GL_ALWAYS:
 252          z |= MACH64_Z_TEST_ALWAYS;
 253          break;
 254       case GL_LESS:
 255          z |= MACH64_Z_TEST_LESS;
 256          break;
 257       case GL_LEQUAL:
 258          z |= MACH64_Z_TEST_LEQUAL;
 259          break;
 260       case GL_EQUAL:
 261          z |= MACH64_Z_TEST_EQUAL;
 262          break;
 263       case GL_GEQUAL:
 264          z |= MACH64_Z_TEST_GEQUAL;
 265          break;
 266       case GL_GREATER:
 267          z |= MACH64_Z_TEST_GREATER;
 268          break;
 269       case GL_NOTEQUAL:
 270          z |= MACH64_Z_TEST_NOTEQUAL;
 271          break;
 272       }
 273
 274       z |=  MACH64_Z_EN;
 275    } else {
 276       z &= ~MACH64_Z_EN;
 277    }
 278
 279    if ( ctx->Depth.Mask ) {
 280       z |=  MACH64_Z_MASK_EN;
 281    } else {
 282       z &= ~MACH64_Z_MASK_EN;
 283    }
 284
 285    if ( mmesa->setup.z_cntl != z ) {
 286       mmesa->setup.z_cntl = z;
 287       mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
 288    }
 289 }
 290
 291 static void mach64DDDepthFunc( GLcontext *ctx, GLenum func )
 292 {
 293    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 294
 295    FLUSH_BATCH( mmesa );
 296    mmesa->new_state |= MACH64_NEW_DEPTH;
 297 }
 298
 299 static void mach64DDDepthMask( GLcontext *ctx, GLboolean flag )
 300 {
 301    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 302
 303    FLUSH_BATCH( mmesa );
 304    mmesa->new_state |= MACH64_NEW_DEPTH;
 305 }
 306
 307 static void mach64DDClearDepth( GLcontext *ctx, GLclampd d )
 308 {
 309    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 310
 311    /* Always have a 16-bit depth buffer.
 312     */
 313    mmesa->ClearDepth = d * 0xffff;
 314 }
 315
 316
 317 /* =============================================================
 318  * Fog
 319  */
 320
 321 static void mach64UpdateFogAttrib( GLcontext *ctx )
 322 {
 323    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 324
 325    CARD32 s = mmesa->setup.scale_3d_cntl;
 326    GLubyte c[4];
 327    CARD32 col;
 328
 329    /* Can't fog if blending is on */
 330    if ( ctx->Color.BlendEnabled )
 331       return;
 332
 333    if ( ctx->Fog.Enabled ) {
 334       s |= MACH64_ALPHA_FOG_EN_FOG;
 335       s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
 336              MACH64_ALPHA_BLEND_DST_MASK |
 337              MACH64_ALPHA_BLEND_SAT);
 338       /* From Utah-glx: "fog color is now dest and fog factor is alpha, so
 339        * use GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA"
 340        */
 341       s |= (MACH64_ALPHA_BLEND_SRC_SRCALPHA |
 342             MACH64_ALPHA_BLEND_DST_INVSRCALPHA);
 343       /* From Utah-glx: "can't use texture alpha when fogging" */
 344       s &= ~MACH64_TEX_MAP_AEN;
 345    } else {
 346       s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
 347              MACH64_ALPHA_BLEND_DST_MASK |
 348              MACH64_ALPHA_BLEND_SAT);
 349       s |= (MACH64_ALPHA_BLEND_SRC_ONE |
 350             MACH64_ALPHA_BLEND_DST_ZERO);
 351       s &= ~MACH64_ALPHA_FOG_EN_FOG;
 352    }
 353
 354    c[0] = FLOAT_TO_UBYTE( ctx->Fog.Color[0] );
 355    c[1] = FLOAT_TO_UBYTE( ctx->Fog.Color[1] );
 356    c[2] = FLOAT_TO_UBYTE( ctx->Fog.Color[2] );
 357    c[3] = FLOAT_TO_UBYTE( ctx->Fog.Color[3] );
 358
 359    col = mach64PackColor( 4, c[0], c[1], c[2], c[3] );
 360
 361    if ( mmesa->setup.dp_fog_clr != col ) {
 362       mmesa->setup.dp_fog_clr = col;
 363       mmesa->dirty |= MACH64_UPLOAD_DP_FOG_CLR;
 364    }
 365    if ( mmesa->setup.scale_3d_cntl != s ) {
 366       mmesa->setup.scale_3d_cntl = s;
 367       mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
 368    }
 369
 370 }
 371
 372 static void mach64DDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
 373 {
 374    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 375
 376    FLUSH_BATCH( mmesa );
 377    mmesa->new_state |= MACH64_NEW_FOG;
 378 }
 379
 380
 381 /* =============================================================
 382  * Clipping
 383  */
 384
 385 static void mach64UpdateClipping( GLcontext *ctx )
 386 {
 387    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 388    mach64ScreenPtr mach64Screen = mmesa->mach64Screen;
 389
 390    if ( mmesa->driDrawable ) {
 391       __DRIdrawable *drawable = mmesa->driDrawable;
 392       int x1 = 0;
 393       int y1 = 0;
 394       int x2 = drawable->w - 1;
 395       int y2 = drawable->h - 1;
 396
 397       if ( ctx->Scissor.Enabled ) {
 398          if ( ctx->Scissor.X > x1 ) {
 399             x1 = ctx->Scissor.X;
 400          }
 401          if ( drawable->h - ctx->Scissor.Y - ctx->Scissor.Height > y1 ) {
 402             y1 = drawable->h - ctx->Scissor.Y - ctx->Scissor.Height;
 403          }
 404          if ( ctx->Scissor.X + ctx->Scissor.Width - 1 < x2 ) {
 405             x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
 406          }
 407          if ( drawable->h - ctx->Scissor.Y - 1 < y2 ) {
 408             y2 = drawable->h - ctx->Scissor.Y - 1;
 409          }
 410       }
 411
 412       x1 += drawable->x;
 413       y1 += drawable->y;
 414       x2 += drawable->x;
 415       y2 += drawable->y;
 416
 417       /* clamp to screen borders */
 418       if (x1 < 0) x1 = 0;
 419       if (y1 < 0) y1 = 0;
 420       if (x2 < 0) x2 = 0;
 421       if (y2 < 0) y2 = 0;
 422       if (x2 > mach64Screen->width-1) x2 = mach64Screen->width-1;
 423       if (y2 > mach64Screen->height-1) y2 = mach64Screen->height-1;
 424
 425       if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
 426          fprintf( stderr, "%s: drawable %3d %3d %3d %3d\n",
 427                   __FUNCTION__,
 428                   drawable->x,
 429                   drawable->y,
 430                   drawable->w,
 431                   drawable->h );
 432          fprintf( stderr, "%s:  scissor %3d %3d %3d %3d\n",
 433                   __FUNCTION__,
 434                   ctx->Scissor.X,
 435                   ctx->Scissor.Y,
 436                   ctx->Scissor.Width,
 437                   ctx->Scissor.Height );
 438          fprintf( stderr, "%s:    final %3d %3d %3d %3d\n",
 439                   __FUNCTION__, x1, y1, x2, y2 );
 440          fprintf( stderr, "\n" );
 441       }
 442
 443       mmesa->setup.sc_top_bottom = ((y1 << 0) |
 444                                     (y2 << 16));
 445
 446       mmesa->setup.sc_left_right = ((x1 << 0) |
 447                                     (x2 << 16));
 448
 449        /* UPLOAD_MISC reduces the dirty state, we just need to
 450        * emit the scissor to the SAREA.  We need to dirty cliprects
 451        * since the scissor and cliprects are intersected to update the
 452        * single hardware scissor
 453        */
 454       mmesa->dirty |= MACH64_UPLOAD_MISC | MACH64_UPLOAD_CLIPRECTS;
 455    }
 456 }
 457
 458 static void mach64DDScissor( GLcontext *ctx,
 459                              GLint x, GLint y, GLsizei w, GLsizei h )
 460 {
 461    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 462
 463    FLUSH_BATCH( mmesa );
 464    mmesa->new_state |= MACH64_NEW_CLIP;
 465 }
 466
 467
 468 /* =============================================================
 469  * Culling
 470  */
 471
 472 static void mach64UpdateCull( GLcontext *ctx )
 473 {
 474    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 475    GLfloat backface_sign = 1;
 476
 477    if ( ctx->Polygon.CullFlag /*&& ctx->PB->primitive == GL_POLYGON*/ ) {
 478       backface_sign = 1;
 479       switch ( ctx->Polygon.CullFaceMode ) {
 480       case GL_BACK:
 481          if ( ctx->Polygon.FrontFace == GL_CCW )
 482             backface_sign = -1;
 483          break;
 484       case GL_FRONT:
 485          if ( ctx->Polygon.FrontFace != GL_CCW )
 486             backface_sign = -1;
 487          break;
 488       default:
 489       case GL_FRONT_AND_BACK:
 490          backface_sign = 0;
 491          break;
 492       }
 493    } else {
 494       backface_sign = 0;
 495    }
 496
 497    mmesa->backface_sign = backface_sign;
 498
 499 }
 500
 501 static void mach64DDCullFace( GLcontext *ctx, GLenum mode )
 502 {
 503    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 504
 505    FLUSH_BATCH( mmesa );
 506    mmesa->new_state |= MACH64_NEW_CULL;
 507 }
 508
 509 static void mach64DDFrontFace( GLcontext *ctx, GLenum mode )
 510 {
 511    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 512
 513    FLUSH_BATCH( mmesa );
 514    mmesa->new_state |= MACH64_NEW_CULL;
 515 }
 516
 517
 518 /* =============================================================
 519  * Masks
 520  */
 521
 522 static void mach64UpdateMasks( GLcontext *ctx )
 523 {
 524    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 525    GLuint mask = 0xffffffff;
 526
 527    /* mach64 can't color mask with alpha blending enabled */
 528    if ( !ctx->Color.BlendEnabled ) {
 529       mask = mach64PackColor( mmesa->mach64Screen->cpp,
 530                               ctx->Color.ColorMask[0][RCOMP],
 531                               ctx->Color.ColorMask[0][GCOMP],
 532                               ctx->Color.ColorMask[0][BCOMP],
 533                               ctx->Color.ColorMask[0][ACOMP] );
 534    }
 535
 536    if ( mmesa->setup.dp_write_mask != mask ) {
 537       mmesa->setup.dp_write_mask = mask;
 538       mmesa->dirty |= MACH64_UPLOAD_DP_WRITE_MASK;
 539    }
 540 }
 541
 542 static void mach64DDColorMask( GLcontext *ctx,
 543                                GLboolean r, GLboolean g,
 544                                GLboolean b, GLboolean a )
 545 {
 546    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 547
 548    FLUSH_BATCH( mmesa );
 549    mmesa->new_state |= MACH64_NEW_MASKS;
 550 }
 551
 552
 553 /* =============================================================
 554  * Rendering attributes
 555  *
 556  * We really don't want to recalculate all this every time we bind a
 557  * texture.  These things shouldn't change all that often, so it makes
 558  * sense to break them out of the core texture state update routines.
 559  */
 560
 561 static void mach64UpdateSpecularLighting( GLcontext *ctx )
 562 {
 563    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 564    GLuint a = mmesa->setup.alpha_tst_cntl;
 565
 566    if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
 567       fprintf( stderr, "%s:\n", __FUNCTION__ );
 568    }
 569
 570    if ( ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR  &&
 571         ctx->Light.Enabled ) {
 572       a |=  MACH64_SPECULAR_LIGHT_EN;
 573    } else {
 574       a &= ~MACH64_SPECULAR_LIGHT_EN;
 575    }
 576
 577    if ( mmesa->setup.alpha_tst_cntl != a ) {
 578       mmesa->setup.alpha_tst_cntl = a;
 579       mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
 580       mmesa->new_state |= MACH64_NEW_CONTEXT;
 581    }
 582 }
 583
 584 static void mach64DDLightModelfv( GLcontext *ctx, GLenum pname,
 585                                   const GLfloat *param )
 586 {
 587    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 588
 589    if ( pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
 590       FLUSH_BATCH( mmesa );
 591       mach64UpdateSpecularLighting(ctx);
 592    }
 593 }
 594
 595 static void mach64DDShadeModel( GLcontext *ctx, GLenum mode )
 596 {
 597    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 598    GLuint s = mmesa->setup.setup_cntl;
 599
 600    s &= ~MACH64_FLAT_SHADE_MASK;
 601
 602    switch ( mode ) {
 603    case GL_FLAT:
 604       s |= MACH64_FLAT_SHADE_VERTEX_3;
 605       break;
 606    case GL_SMOOTH:
 607       s |= MACH64_FLAT_SHADE_OFF;
 608       break;
 609    default:
 610       return;
 611    }
 612
 613    if ( mmesa->setup.setup_cntl != s ) {
 614       FLUSH_BATCH( mmesa );
 615       mmesa->setup.setup_cntl = s;
 616
 617       mmesa->dirty |= MACH64_UPLOAD_SETUP_CNTL;
 618    }
 619 }
 620
 621
 622 /* =============================================================
 623  * Viewport
 624  */
 625
 626
 627 void mach64CalcViewport( GLcontext *ctx )
 628 {
 629    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 630    const GLfloat *v = ctx->Viewport._WindowMap.m;
 631    GLfloat *m = mmesa->hw_viewport;
 632
 633    /* See also mach64_translate_vertex.
 634     */
 635    m[MAT_SX] =   v[MAT_SX];
 636    m[MAT_TX] =   v[MAT_TX] + (GLfloat)mmesa->drawX + SUBPIXEL_X;
 637    m[MAT_SY] = - v[MAT_SY];
 638    m[MAT_TY] = - v[MAT_TY] + mmesa->driDrawable->h + (GLfloat)mmesa->drawY + SUBPIXEL_Y;
 639    m[MAT_SZ] =   v[MAT_SZ] * mmesa->depth_scale;
 640    m[MAT_TZ] =   v[MAT_TZ] * mmesa->depth_scale;
 641
 642    mmesa->SetupNewInputs = ~0;
 643 }
 644
 645 static void mach64Viewport( GLcontext *ctx,
 646                           GLint x, GLint y,
 647                           GLsizei width, GLsizei height )
 648 {
 649    mach64CalcViewport( ctx );
 650 }
 651
 652 static void mach64DepthRange( GLcontext *ctx,
 653                             GLclampd nearval, GLclampd farval )
 654 {
 655    mach64CalcViewport( ctx );
 656 }
 657
 658
 659 /* =============================================================
 660  * Miscellaneous
 661  */
 662
 663 static void mach64DDClearColor( GLcontext *ctx,
 664                                 const GLfloat color[4] )
 665 {
 666    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 667    GLubyte c[4];
 668
 669    CLAMPED_FLOAT_TO_UBYTE(c[0], color[0]);
 670    CLAMPED_FLOAT_TO_UBYTE(c[1], color[1]);
 671    CLAMPED_FLOAT_TO_UBYTE(c[2], color[2]);
 672    CLAMPED_FLOAT_TO_UBYTE(c[3], color[3]);
 673
 674    mmesa->ClearColor = mach64PackColor( mmesa->mach64Screen->cpp,
 675                                         c[0], c[1], c[2], c[3] );
 676 }
 677
 678 static void mach64DDLogicOpCode( GLcontext *ctx, GLenum opcode )
 679 {
 680    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 681
 682    if ( ctx->Color.ColorLogicOpEnabled ) {
 683       FLUSH_BATCH( mmesa );
 684
 685       FALLBACK( mmesa, MACH64_FALLBACK_LOGICOP, opcode != GL_COPY);
 686    }
 687 }
 688
 689 void mach64SetCliprects( GLcontext *ctx, GLenum mode )
 690 {
 691    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 692    __DRIdrawable *dPriv = mmesa->driDrawable;
 693
 694    switch ( mode ) {
 695    case GL_FRONT_LEFT:
 696       mmesa->numClipRects = dPriv->numClipRects;
 697       mmesa->pClipRects = dPriv->pClipRects;
 698       mmesa->drawX = dPriv->x;
 699       mmesa->drawY = dPriv->y;
 700       break;
 701    case GL_BACK_LEFT:
 702       if ( dPriv->numBackClipRects == 0 ) {
 703          mmesa->numClipRects = dPriv->numClipRects;
 704          mmesa->pClipRects = dPriv->pClipRects;
 705          mmesa->drawX = dPriv->x;
 706          mmesa->drawY = dPriv->y;
 707       } else {
 708          mmesa->numClipRects = dPriv->numBackClipRects;
 709          mmesa->pClipRects = dPriv->pBackClipRects;
 710          mmesa->drawX = dPriv->backX;
 711          mmesa->drawY = dPriv->backY;
 712       }
 713       break;
 714    default:
 715       return;
 716    }
 717
 718    mach64UpdateClipping( ctx );
 719
 720    mmesa->dirty |= MACH64_UPLOAD_CLIPRECTS;
 721 }
 722
 723 static void mach64DDDrawBuffer( GLcontext *ctx, GLenum mode )
 724 {
 725    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 726
 727    FLUSH_BATCH( mmesa );
 728
 729    if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
 730       /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
 731       FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_TRUE );
 732       return;
 733    }
 734
 735    switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {
 736    case BUFFER_FRONT_LEFT:
 737       FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_FALSE );
 738       mach64SetCliprects( ctx, GL_FRONT_LEFT );
 739       if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
 740          fprintf(stderr,"%s: BUFFER_BIT_FRONT_LEFT\n", __FUNCTION__);
 741       break;
 742    case BUFFER_BACK_LEFT:
 743       FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_FALSE );
 744       mach64SetCliprects( ctx, GL_BACK_LEFT );
 745       if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
 746          fprintf(stderr,"%s: BUFFER_BIT_BACK_LEFT\n", __FUNCTION__);
 747       break;
 748    default:
 749       FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_TRUE );
 750       if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
 751          fprintf(stderr,"%s: fallback (mode=%d)\n", __FUNCTION__, mode);
 752       break;
 753    }
 754
 755    mmesa->setup.dst_off_pitch = (((mmesa->drawPitch/8) << 22) |
 756                                  (mmesa->drawOffset >> 3));
 757
 758    mmesa->dirty |= MACH64_UPLOAD_DST_OFF_PITCH;
 759 }
 760
 761 static void mach64DDReadBuffer( GLcontext *ctx, GLenum mode )
 762 {
 763    /* nothing, until we implement h/w glRead/CopyPixels or CopyTexImage */
 764 }
 765
 766 /* =============================================================
 767  * State enable/disable
 768  */
 769
 770 static void mach64DDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
 771 {
 772    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 773
 774    if ( MACH64_DEBUG & DEBUG_VERBOSE_API ) {
 775       fprintf( stderr, "%s( %s = %s )\n",
 776                __FUNCTION__, _mesa_lookup_enum_by_nr( cap ),
 777                state ? "GL_TRUE" : "GL_FALSE" );
 778    }
 779
 780    switch ( cap ) {
 781    case GL_ALPHA_TEST:
 782       FLUSH_BATCH( mmesa );
 783       mmesa->new_state |= MACH64_NEW_ALPHA;
 784       break;
 785
 786    case GL_BLEND:
 787       FLUSH_BATCH( mmesa );
 788       mmesa->new_state |= MACH64_NEW_ALPHA;
 789
 790       /* enable(GL_BLEND) affects ColorLogicOpEnabled.
 791        */
 792       FALLBACK( mmesa, MACH64_FALLBACK_LOGICOP,
 793                 (ctx->Color.ColorLogicOpEnabled &&
 794                  ctx->Color.LogicOp != GL_COPY));
 795       break;
 796
 797    case GL_CULL_FACE:
 798       FLUSH_BATCH( mmesa );
 799       mmesa->new_state |= MACH64_NEW_CULL;
 800       break;
 801
 802    case GL_DEPTH_TEST:
 803       FLUSH_BATCH( mmesa );
 804       mmesa->new_state |= MACH64_NEW_DEPTH;
 805       break;
 806
 807    case GL_DITHER:
 808       do {
 809          GLuint s = mmesa->setup.scale_3d_cntl;
 810          FLUSH_BATCH( mmesa );
 811
 812          if ( ctx->Color.DitherFlag ) {
 813             /* Dithering causes problems w/ 24bpp depth */
 814             if ( mmesa->mach64Screen->cpp == 4 )
 815                s |=  MACH64_ROUND_EN;
 816             else
 817                s |=  MACH64_DITHER_EN;
 818          } else {
 819             s &= ~MACH64_DITHER_EN;
 820             s &= ~MACH64_ROUND_EN;
 821          }
 822
 823          if ( mmesa->setup.scale_3d_cntl != s ) {
 824             mmesa->setup.scale_3d_cntl = s;
 825             mmesa->dirty |= ( MACH64_UPLOAD_SCALE_3D_CNTL );
 826          }
 827       } while (0);
 828       break;
 829
 830    case GL_FOG:
 831       FLUSH_BATCH( mmesa );
 832       mmesa->new_state |= MACH64_NEW_FOG;
 833       break;
 834
 835    case GL_INDEX_LOGIC_OP:
 836    case GL_COLOR_LOGIC_OP:
 837       FLUSH_BATCH( mmesa );
 838       FALLBACK( mmesa, MACH64_FALLBACK_LOGICOP,
 839                 state && ctx->Color.LogicOp != GL_COPY );
 840       break;
 841
 842    case GL_LIGHTING:
 843       mach64UpdateSpecularLighting(ctx);
 844       break;
 845
 846    case GL_SCISSOR_TEST:
 847       FLUSH_BATCH( mmesa );
 848       mmesa->scissor = state;
 849       mmesa->new_state |= MACH64_NEW_CLIP;
 850       break;
 851
 852    case GL_STENCIL_TEST:
 853       FLUSH_BATCH( mmesa );
 854       FALLBACK( mmesa, MACH64_FALLBACK_STENCIL, state );
 855       break;
 856
 857    case GL_TEXTURE_1D:
 858    case GL_TEXTURE_2D:
 859    case GL_TEXTURE_3D:
 860       FLUSH_BATCH( mmesa );
 861       mmesa->new_state |= MACH64_NEW_TEXTURE;
 862       break;
 863
 864    default:
 865       return;
 866    }
 867 }
 868
 869 /* =============================================================
 870  * Render mode
 871  */
 872
 873 static void mach64DDRenderMode( GLcontext *ctx, GLenum mode )
 874 {
 875    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 876    FALLBACK( mmesa, MACH64_FALLBACK_RENDER_MODE, (mode != GL_RENDER) );
 877 }
 878
 879 /* =============================================================
 880  * State initialization, management
 881  */
 882
 883 static void mach64DDPrintDirty( const char *msg, GLuint state )
 884 {
 885    fprintf( stderr,
 886             "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s\n",
 887             msg,
 888             state,
 889             (state & MACH64_UPLOAD_DST_OFF_PITCH) ? "dst_off_pitch, " : "",
 890             (state & MACH64_UPLOAD_Z_ALPHA_CNTL)  ? "z_alpha_cntl, " : "",
 891             (state & MACH64_UPLOAD_SCALE_3D_CNTL) ? "scale_3d_cntl, " : "",
 892             (state & MACH64_UPLOAD_DP_FOG_CLR)    ? "dp_fog_clr, " : "",
 893             (state & MACH64_UPLOAD_DP_WRITE_MASK) ? "dp_write_mask, " : "",
 894             (state & MACH64_UPLOAD_DP_PIX_WIDTH)  ? "dp_pix_width, " : "",
 895             (state & MACH64_UPLOAD_SETUP_CNTL)    ? "setup_cntl, " : "",
 896             (state & MACH64_UPLOAD_MISC)          ? "misc, " : "",
 897             (state & MACH64_UPLOAD_TEXTURE)       ? "texture, " : "",
 898             (state & MACH64_UPLOAD_TEX0IMAGE)     ? "tex0 image, " : "",
 899             (state & MACH64_UPLOAD_TEX1IMAGE)     ? "tex1 image, " : "",
 900             (state & MACH64_UPLOAD_CLIPRECTS)     ? "cliprects, " : "" );
 901 }
 902
 903 /*
 904  * Load the current context's state into the hardware.
 905  *
 906  * NOTE: Be VERY careful about ensuring the context state is marked for
 907  * upload, the only place it shouldn't be uploaded is when the setup
 908  * state has changed in ReducedPrimitiveChange as this comes right after
 909  * a state update.
 910  *
 911  * Blits of any type should always upload the context and masks after
 912  * they are done.
 913  */
 914 void mach64EmitHwStateLocked( mach64ContextPtr mmesa )
 915 {
 916    drm_mach64_sarea_t *sarea = mmesa->sarea;
 917    drm_mach64_context_regs_t *regs = &(mmesa->setup);
 918    mach64TexObjPtr t0 = mmesa->CurrentTexObj[0];
 919    mach64TexObjPtr t1 = mmesa->CurrentTexObj[1];
 920
 921    if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
 922       mach64DDPrintDirty( __FUNCTION__, mmesa->dirty );
 923    }
 924
 925    if ( t0 && t1 && mmesa->mach64Screen->numTexHeaps > 1 ) {
 926       if (t0->heap != t1->heap ||
 927              (mmesa->dirty & MACH64_UPLOAD_TEX0IMAGE) ||
 928              (mmesa->dirty & MACH64_UPLOAD_TEX1IMAGE))
 929          mach64UploadMultiTexImages( mmesa, t0, t1 );
 930    } else {
 931       if ( mmesa->dirty & MACH64_UPLOAD_TEX0IMAGE ) {
 932          if ( t0 ) mach64UploadTexImages( mmesa, t0 );
 933       }
 934       if ( mmesa->dirty & MACH64_UPLOAD_TEX1IMAGE ) {
 935          if ( t1 ) mach64UploadTexImages( mmesa, t1 );
 936       }
 937    }
 938
 939    if ( mmesa->dirty & (MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_MISC) ) {
 940       memcpy( &sarea->context_state, regs,
 941               MACH64_NR_CONTEXT_REGS * sizeof(GLuint) );
 942    }
 943
 944    if ( mmesa->dirty & MACH64_UPLOAD_TEXTURE ) {
 945       mach64EmitTexStateLocked( mmesa, t0, t1 );
 946    }
 947
 948    sarea->vertsize = mmesa->vertex_size;
 949
 950    /* Turn off the texture cache flushing.
 951     */
 952    mmesa->setup.tex_cntl &= ~MACH64_TEX_CACHE_FLUSH;
 953
 954    sarea->dirty |= mmesa->dirty;
 955
 956    mmesa->dirty &= MACH64_UPLOAD_CLIPRECTS;
 957 }
 958
 959 static void mach64DDPrintState( const char *msg, GLuint flags )
 960 {
 961    fprintf( stderr,
 962             "%s: (0x%x) %s%s%s%s%s%s%s%s%s\n",
 963             msg,
 964             flags,
 965             (flags & MACH64_NEW_CONTEXT)        ? "context, " : "",
 966             (flags & MACH64_NEW_ALPHA)          ? "alpha, " : "",
 967             (flags & MACH64_NEW_DEPTH)          ? "depth, " : "",
 968             (flags & MACH64_NEW_FOG)            ? "fog, " : "",
 969             (flags & MACH64_NEW_CLIP)           ? "clip, " : "",
 970             (flags & MACH64_NEW_TEXTURE)        ? "texture, " : "",
 971             (flags & MACH64_NEW_CULL)           ? "cull, " : "",
 972             (flags & MACH64_NEW_MASKS)          ? "masks, " : "",
 973             (flags & MACH64_NEW_WINDOW)         ? "window, " : "" );
 974 }
 975
 976 /* Update the hardware state */
 977 void mach64DDUpdateHWState( GLcontext *ctx )
 978 {
 979    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 980    int new_state = mmesa->new_state;
 981
 982    if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
 983       fprintf( stderr, "%s:\n", __FUNCTION__ );
 984    }
 985
 986    if ( new_state )
 987    {
 988       FLUSH_BATCH( mmesa );
 989
 990       mmesa->new_state = 0;
 991
 992       if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG )
 993          mach64DDPrintState( __FUNCTION__, new_state );
 994
 995       /* Update the various parts of the context's state.
 996        */
 997       if ( new_state & MACH64_NEW_ALPHA )
 998          mach64UpdateAlphaMode( ctx );
 999
1000       if ( new_state & MACH64_NEW_DEPTH )
1001          mach64UpdateZMode( ctx );
1002
1003       if ( new_state & MACH64_NEW_FOG )
1004          mach64UpdateFogAttrib( ctx );
1005
1006       if ( new_state & MACH64_NEW_CLIP )
1007          mach64UpdateClipping( ctx );
1008
1009       if ( new_state & MACH64_NEW_WINDOW )
1010          mach64CalcViewport( ctx );
1011
1012       if ( new_state & MACH64_NEW_CULL )
1013          mach64UpdateCull( ctx );
1014
1015       if ( new_state & MACH64_NEW_MASKS )
1016          mach64UpdateMasks( ctx );
1017
1018       if ( new_state & MACH64_NEW_TEXTURE )
1019          mach64UpdateTextureState( ctx );
1020    }
1021 }
1022
1023
1024 static void mach64DDInvalidateState( GLcontext *ctx, GLuint new_state )
1025 {
1026    _swrast_InvalidateState( ctx, new_state );
1027    _swsetup_InvalidateState( ctx, new_state );
1028    _vbo_InvalidateState( ctx, new_state );
1029    _tnl_InvalidateState( ctx, new_state );
1030    MACH64_CONTEXT(ctx)->NewGLState |= new_state;
1031 }
1032
1033
1034 /* Initialize the context's hardware state */
1035 void mach64DDInitState( mach64ContextPtr mmesa )
1036 {
1037    GLuint format;
1038
1039    switch ( mmesa->mach64Screen->cpp ) {
1040    case 2:
1041       format = MACH64_DATATYPE_RGB565;
1042       break;
1043    case 4:
1044       format = MACH64_DATATYPE_ARGB8888;
1045       break;
1046    default:
1047       fprintf( stderr, "Error: Unsupported pixel depth... exiting\n" );
1048       exit( -1 );
1049    }
1050
1051    /* Always have a 16-bit depth buffer
1052     * but Z coordinates are specified in 16.1 format to the setup engine.
1053     */
1054    mmesa->depth_scale = 2.0;
1055
1056    mmesa->ClearColor = 0x00000000;
1057    mmesa->ClearDepth = 0x0000ffff;
1058
1059    mmesa->Fallback = 0;
1060
1061    if ( mmesa->glCtx->Visual.doubleBufferMode ) {
1062       mmesa->drawOffset = mmesa->readOffset = mmesa->mach64Screen->backOffset;
1063       mmesa->drawPitch  = mmesa->readPitch  = mmesa->mach64Screen->backPitch;
1064    } else {
1065       mmesa->drawOffset = mmesa->readOffset = mmesa->mach64Screen->frontOffset;
1066       mmesa->drawPitch  = mmesa->readPitch  = mmesa->mach64Screen->frontPitch;
1067    }
1068
1069    /* Harware state:
1070     */
1071    mmesa->setup.dst_off_pitch = (((mmesa->drawPitch/8) << 22) |
1072                                  (mmesa->drawOffset >> 3));
1073
1074    mmesa->setup.z_off_pitch = (((mmesa->mach64Screen->depthPitch/8) << 22) |
1075                                (mmesa->mach64Screen->depthOffset >> 3));
1076
1077    mmesa->setup.z_cntl = (MACH64_Z_TEST_LESS |
1078                           MACH64_Z_MASK_EN);
1079
1080    mmesa->setup.alpha_tst_cntl = (MACH64_ALPHA_TEST_ALWAYS |
1081                                   MACH64_ALPHA_DST_SRCALPHA |
1082                                   MACH64_ALPHA_TST_SRC_TEXEL |
1083                                   (0 << MACH64_REF_ALPHA_SHIFT));
1084
1085    mmesa->setup.scale_3d_cntl = (MACH64_SCALE_PIX_EXPAND_DYNAMIC_RANGE |
1086                                  /*  MACH64_SCALE_DITHER_ERROR_DIFFUSE | */
1087                                  MACH64_SCALE_DITHER_2D_TABLE |
1088                                  /*  MACH64_DITHER_INIT_CURRENT | */
1089                                  MACH64_DITHER_INIT_RESET |
1090                                  MACH64_SCALE_3D_FCN_SHADE |
1091                                  MACH64_ALPHA_FOG_DIS |
1092                                  MACH64_ALPHA_BLEND_SRC_ONE |
1093                                  MACH64_ALPHA_BLEND_DST_ZERO |
1094                                  MACH64_TEX_LIGHT_FCN_MODULATE |
1095                                  MACH64_MIP_MAP_DISABLE |
1096                                  MACH64_BILINEAR_TEX_EN |
1097                                  MACH64_TEX_BLEND_FCN_LINEAR);
1098
1099    /* GL spec says dithering initially enabled, but dithering causes
1100     * problems w/ 24bpp depth
1101     */
1102    if ( mmesa->mach64Screen->cpp == 4 )
1103       mmesa->setup.scale_3d_cntl |= MACH64_ROUND_EN;
1104    else
1105       mmesa->setup.scale_3d_cntl |= MACH64_DITHER_EN;
1106
1107    mmesa->setup.sc_left_right = 0x1fff0000;
1108    mmesa->setup.sc_top_bottom = 0x3fff0000;
1109
1110    mmesa->setup.dp_fog_clr    = 0x00ffffff;
1111    mmesa->setup.dp_write_mask = 0xffffffff;
1112
1113    mmesa->setup.dp_pix_width = ((format << 0) |
1114                                 (format << 4) |
1115                                 (format << 8) |
1116                                 (format << 16) |
1117                                 (format << 28));
1118
1119    mmesa->setup.dp_mix = (MACH64_BKGD_MIX_S |
1120                           MACH64_FRGD_MIX_S);
1121    mmesa->setup.dp_src = (MACH64_BKGD_SRC_3D |
1122                           MACH64_FRGD_SRC_3D |
1123                           MACH64_MONO_SRC_ONE);
1124
1125    mmesa->setup.clr_cmp_cntl  = 0x00000000;
1126    mmesa->setup.gui_traj_cntl = (MACH64_DST_X_LEFT_TO_RIGHT |
1127                                  MACH64_DST_Y_TOP_TO_BOTTOM);
1128
1129    mmesa->setup.setup_cntl = (MACH64_FLAT_SHADE_OFF |
1130                               MACH64_SOLID_MODE_OFF |
1131                               MACH64_LOG_MAX_INC_ADJ);
1132    mmesa->setup.setup_cntl = 0;
1133
1134    mmesa->setup.tex_size_pitch = 0x00000000;
1135
1136    mmesa->setup.tex_cntl = ((0 << MACH64_LOD_BIAS_SHIFT) |
1137                             (0 << MACH64_COMP_FACTOR_SHIFT) |
1138                             MACH64_COMP_COMBINE_MODULATE |
1139                             MACH64_COMP_BLEND_NEAREST |
1140                             MACH64_COMP_FILTER_NEAREST |
1141                             /* MACH64_TEXTURE_TILING | */
1142 #ifdef MACH64_PREMULT_TEXCOORDS
1143                             MACH64_TEX_ST_DIRECT |
1144 #endif
1145                             MACH64_TEX_SRC_LOCAL |
1146                             MACH64_TEX_UNCOMPRESSED |
1147                             MACH64_TEX_CACHE_FLUSH |
1148                             MACH64_TEX_CACHE_SIZE_4K);
1149
1150    mmesa->setup.secondary_tex_off = 0x00000000;
1151    mmesa->setup.tex_offset = 0x00000000;
1152
1153    mmesa->new_state = MACH64_NEW_ALL;
1154 }
1155
1156 /* Initialize the driver's state functions.
1157   */
1158 void mach64DDInitStateFuncs( GLcontext *ctx )
1159 {
1160    ctx->Driver.UpdateState              = mach64DDInvalidateState;
1161
1162    ctx->Driver.ClearIndex               = NULL;
1163    ctx->Driver.ClearColor               = mach64DDClearColor;
1164    ctx->Driver.DrawBuffer               = mach64DDDrawBuffer;
1165    ctx->Driver.ReadBuffer               = mach64DDReadBuffer;
1166
1167    ctx->Driver.IndexMask                = NULL;
1168    ctx->Driver.ColorMask                = mach64DDColorMask;
1169    ctx->Driver.AlphaFunc                = mach64DDAlphaFunc;
1170    ctx->Driver.BlendEquationSeparate    = mach64DDBlendEquationSeparate;
1171    ctx->Driver.BlendFuncSeparate        = mach64DDBlendFuncSeparate;
1172    ctx->Driver.ClearDepth               = mach64DDClearDepth;
1173    ctx->Driver.CullFace                 = mach64DDCullFace;
1174    ctx->Driver.FrontFace                = mach64DDFrontFace;
1175    ctx->Driver.DepthFunc                = mach64DDDepthFunc;
1176    ctx->Driver.DepthMask                = mach64DDDepthMask;
1177    ctx->Driver.Enable                   = mach64DDEnable;
1178    ctx->Driver.Fogfv                    = mach64DDFogfv;
1179    ctx->Driver.Hint                     = NULL;
1180    ctx->Driver.Lightfv                  = NULL;
1181    ctx->Driver.LightModelfv             = mach64DDLightModelfv;
1182    ctx->Driver.LogicOpcode              = mach64DDLogicOpCode;
1183    ctx->Driver.PolygonMode              = NULL;
1184    ctx->Driver.PolygonStipple           = NULL;
1185    ctx->Driver.RenderMode               = mach64DDRenderMode;
1186    ctx->Driver.Scissor                  = mach64DDScissor;
1187    ctx->Driver.ShadeModel               = mach64DDShadeModel;
1188
1189    ctx->Driver.DepthRange               = mach64DepthRange;
1190    ctx->Driver.Viewport                 = mach64Viewport;
1191 }