自学教程：C++ I810_STATECHANGE函数代码示例

static void i810AlphaFunc(struct gl_context *ctx, GLenum func, GLfloat ref){   i810ContextPtr imesa = I810_CONTEXT(ctx);   GLuint a = (ZA_UPDATE_ALPHAFUNC|ZA_UPDATE_ALPHAREF);   GLubyte refByte;   CLAMPED_FLOAT_TO_UBYTE(refByte, ref);   switch (ctx->Color.AlphaFunc) {   case GL_NEVER:    a |= ZA_ALPHA_NEVER;    break;   case GL_LESS:     a |= ZA_ALPHA_LESS;     break;   case GL_GEQUAL:   a |= ZA_ALPHA_GEQUAL;   break;   case GL_LEQUAL:   a |= ZA_ALPHA_LEQUAL;   break;   case GL_GREATER:  a |= ZA_ALPHA_GREATER;  break;   case GL_NOTEQUAL: a |= ZA_ALPHA_NOTEQUAL; break;   case GL_EQUAL:    a |= ZA_ALPHA_EQUAL;    break;   case GL_ALWAYS:   a |= ZA_ALPHA_ALWAYS;   break;   default: return;   }   a |= ((refByte & 0xfc) << ZA_ALPHAREF_SHIFT);   I810_STATECHANGE(imesa, I810_UPLOAD_CTX);   imesa->Setup[I810_CTXREG_ZA] &= ~(ZA_ALPHA_MASK|ZA_ALPHAREF_MASK);   imesa->Setup[I810_CTXREG_ZA] |= a;}

static void set_color_stage( unsigned color, int stage,			      i810ContextPtr imesa ){   if ( color != imesa->Setup[I810_CTXREG_MC0 + stage] ) {      I810_STATECHANGE( imesa, I810_UPLOAD_CTX );      imesa->Setup[I810_CTXREG_MC0 + stage] = color;   }}

static void set_alpha_stage( unsigned alpha, int stage,				    i810ContextPtr imesa ){   if ( alpha != imesa->Setup[I810_CTXREG_MA0 + stage] ) {      I810_STATECHANGE( imesa, I810_UPLOAD_CTX );      imesa->Setup[I810_CTXREG_MA0 + stage] = alpha;   }}

/* In Mesa 3.5 we can reliably do native flatshading. */static void i810ShadeModel(struct gl_context *ctx, GLenum mode){   i810ContextPtr imesa = I810_CONTEXT(ctx);   I810_STATECHANGE(imesa, I810_UPLOAD_CTX);   if (mode == GL_FLAT)      imesa->Setup[I810_CTXREG_LCS] |= LCS_INTERP_FLAT;   else      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_INTERP_FLAT;}

/* This is called with the lock held.  May have to eject our own and/or * other client's texture objects to make room for the upload. */int i810UploadTexImagesLocked( i810ContextPtr imesa, i810TextureObjectPtr t ){   int i;   int ofs;   int numLevels;   /* Do we need to eject LRU texture objects?    */   if (!t->base.memBlock) {      int heap;             heap = driAllocateTexture( imesa->texture_heaps, imesa->nr_heaps,				 (driTextureObject *) t);            if ( heap == -1 ) {	return -1;      }            ofs = t->base.memBlock->ofs;      t->BufAddr = imesa->i810Screen->tex.map + ofs;      t->Setup[I810_TEXREG_MI3] = imesa->i810Screen->textureOffset + ofs;            if (t == imesa->CurrentTexObj[0])	I810_STATECHANGE(imesa, I810_UPLOAD_TEX0);            if (t == imesa->CurrentTexObj[1])	 I810_STATECHANGE(imesa, I810_UPLOAD_TEX1);             /*      i810UpdateTexLRU( imesa, t );*/     }   driUpdateTextureLRU( (driTextureObject *) t );      if (imesa->texture_heaps[0]->timestamp >= GET_DISPATCH_AGE(imesa))      i810WaitAgeLocked( imesa, imesa->texture_heaps[0]->timestamp );   numLevels = t->base.lastLevel - t->base.firstLevel + 1;   for (i = 0 ; i < numLevels ; i++)      if (t->base.dirty_images[0] & (1<<i))	 i810UploadTexLevel( imesa, t, i );   t->base.dirty_images[0] = 0;   return 0;}  

static void i810DepthMask(struct gl_context *ctx, GLboolean flag){   i810ContextPtr imesa = I810_CONTEXT(ctx);   I810_STATECHANGE(imesa, I810_UPLOAD_CTX);   if (flag)      imesa->Setup[I810_CTXREG_B2] |= B2_ZB_WRITE_ENABLE;   else      imesa->Setup[I810_CTXREG_B2] &= ~B2_ZB_WRITE_ENABLE;}

static void i810BlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB,				     GLenum dfactorRGB, GLenum sfactorA,				     GLenum dfactorA ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   GLuint a = SDM_UPDATE_SRC_BLEND | SDM_UPDATE_DST_BLEND;   GLboolean fallback = GL_FALSE;   switch (ctx->Color.BlendSrcRGB) {   case GL_ZERO:                a |= SDM_SRC_ZERO; break;   case GL_SRC_ALPHA:           a |= SDM_SRC_SRC_ALPHA; break;   case GL_ONE:                 a |= SDM_SRC_ONE; break;   case GL_DST_COLOR:           a |= SDM_SRC_DST_COLOR; break;   case GL_ONE_MINUS_DST_COLOR: a |= SDM_SRC_INV_DST_COLOR; break;   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_SRC_INV_SRC_ALPHA; break;   case GL_DST_ALPHA:           a |= SDM_SRC_ONE; break;   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_SRC_ZERO; break;   case GL_SRC_ALPHA_SATURATE:  /*a |= SDM_SRC_SRC_ALPHA; break;*/   case GL_CONSTANT_COLOR:   case GL_ONE_MINUS_CONSTANT_COLOR:   case GL_CONSTANT_ALPHA:   case GL_ONE_MINUS_CONSTANT_ALPHA:      fallback = GL_TRUE;      break;   default:      return;   }   switch (ctx->Color.BlendDstRGB) {   case GL_SRC_ALPHA:           a |= SDM_DST_SRC_ALPHA; break;   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_DST_INV_SRC_ALPHA; break;   case GL_ZERO:                a |= SDM_DST_ZERO; break;   case GL_ONE:                 a |= SDM_DST_ONE; break;   case GL_SRC_COLOR:           a |= SDM_DST_SRC_COLOR; break;   case GL_ONE_MINUS_SRC_COLOR: a |= SDM_DST_INV_SRC_COLOR; break;   case GL_DST_ALPHA:           a |= SDM_DST_ONE; break;   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_DST_ZERO; break;   case GL_CONSTANT_COLOR:   case GL_ONE_MINUS_CONSTANT_COLOR:   case GL_CONSTANT_ALPHA:   case GL_ONE_MINUS_CONSTANT_ALPHA:      fallback = GL_TRUE;      break;   default:      return;   }   FALLBACK( imesa, I810_FALLBACK_BLEND_FUNC, fallback);   if (!fallback) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_SDM] &= ~(SDM_SRC_MASK|SDM_DST_MASK);      imesa->Setup[I810_CTXREG_SDM] |= a;   }}

/* ============================================================= * Fog */static void i810Fogfv(struct gl_context *ctx, GLenum pname, const GLfloat *param){   i810ContextPtr imesa = I810_CONTEXT(ctx);   if (pname == GL_FOG_COLOR) {      GLuint color = (((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) |		      ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) |		      ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0));      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_FOG] = ((GFX_OP_FOG_COLOR | color) &				      ~FOG_RESERVED_MASK);   }}

/* But the 815 has it... */static void i810LightModelfv_i815(struct gl_context *ctx, GLenum pname,				    const GLfloat *param){   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL)   {      i810ContextPtr imesa = I810_CONTEXT( ctx );      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)	 imesa->Setup[I810_CTXREG_B1] |= B1_SPEC_ENABLE;      else	 imesa->Setup[I810_CTXREG_B1] &= ~B1_SPEC_ENABLE;   }}

static void i810LineWidth( GLcontext *ctx, GLfloat widthf ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   int width = (int)ctx->Line._Width;   imesa->LcsLineWidth = 0;   if (width & 1) imesa->LcsLineWidth |= LCS_LINEWIDTH_1_0;   if (width & 2) imesa->LcsLineWidth |= LCS_LINEWIDTH_2_0;   if (imesa->reduced_primitive == GL_LINES) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_3_0;      imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsLineWidth;   }}

static void i810PointSize( GLcontext *ctx, GLfloat sz ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   int size = (int)ctx->Point._Size;   imesa->LcsPointSize = 0;   if (size & 1) imesa->LcsPointSize |= LCS_LINEWIDTH_1_0;   if (size & 2) imesa->LcsPointSize |= LCS_LINEWIDTH_2_0;   if (imesa->reduced_primitive == GL_POINTS) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_3_0;      imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsPointSize;   }}

static void i810TexEnv( GLcontext *ctx, GLenum target, 			GLenum pname, const GLfloat *param ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   GLuint unit = ctx->Texture.CurrentUnit;   /* Only one env color.  Need a fallback if env colors are different    * and texture setup references env color in both units.      */   switch (pname) {   case GL_TEXTURE_ENV_COLOR: {      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];      GLfloat *fc = texUnit->EnvColor;      GLuint r, g, b, a, col;      CLAMPED_FLOAT_TO_UBYTE(r, fc[0]);      CLAMPED_FLOAT_TO_UBYTE(g, fc[1]);      CLAMPED_FLOAT_TO_UBYTE(b, fc[2]);      CLAMPED_FLOAT_TO_UBYTE(a, fc[3]);      col = ((a << 24) | 	     (r << 16) | 	     (g <<  8) | 	     (b <<  0));       if (imesa->Setup[I810_CTXREG_CF1] != col) {	 I810_STATECHANGE(imesa, I810_UPLOAD_CTX);		 imesa->Setup[I810_CTXREG_CF1] = col;            }      break;   }   case GL_TEXTURE_ENV_MODE:      imesa->TexEnvImageFmt[unit] = 0; /* force recalc of env state */      break;   case GL_TEXTURE_LOD_BIAS_EXT:      {         struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current;         i810TextureObjectPtr t = (i810TextureObjectPtr) tObj->DriverData;         t->Setup[I810_TEXREG_MLC] &= ~(MLC_LOD_BIAS_MASK);         t->Setup[I810_TEXREG_MLC] |= i810ComputeLodBias(*param);      }      break;   default:      break;   }} 

/* ============================================================= * Polygon stipple * * The i810 supports a 4x4 stipple natively, GL wants 32x32. * Fortunately stipple is usually a repeating pattern. */static void i810PolygonStipple( struct gl_context *ctx, const GLubyte *mask ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   const GLubyte *m = mask;   GLubyte p[4];   int i,j,k;   int active = (ctx->Polygon.StippleFlag &&		 imesa->reduced_primitive == GL_TRIANGLES);   GLuint newMask;   if (active) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE;   }   p[0] = mask[12] & 0xf; p[0] |= p[0] << 4;   p[1] = mask[8] & 0xf; p[1] |= p[1] << 4;   p[2] = mask[4] & 0xf; p[2] |= p[2] << 4;   p[3] = mask[0] & 0xf; p[3] |= p[3] << 4;   for (k = 0 ; k < 8 ; k++)      for (j = 0 ; j < 4; j++)	 for (i = 0 ; i < 4 ; i++)	    if (*m++ != p[j]) {	       imesa->stipple_in_hw = 0;	       return;	    }   newMask = ((p[0] & 0xf) << 0) |             ((p[1] & 0xf) << 4) |             ((p[2] & 0xf) << 8) |             ((p[3] & 0xf) << 12);   if (newMask == 0xffff) {      /* this is needed to make conform pass */      imesa->stipple_in_hw = 0;      return;   }   imesa->Setup[I810_CTXREG_ST1] &= ~0xffff;   imesa->Setup[I810_CTXREG_ST1] |= newMask;   imesa->stipple_in_hw = 1;   if (active)      imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE;}

void i810DrawBuffer(GLcontext *ctx, GLenum mode ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   int front = 0;     /*    * _DrawDestMask is easier to cope with than <mode>.    */   switch ( ctx->Color._DrawDestMask[0] ) {   case DD_FRONT_LEFT_BIT:     front = 1;     break;   case DD_BACK_LEFT_BIT:     front = 0;     break;   default:      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */      FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   if ( imesa->sarea->pf_current_page == 1 )      front ^= 1;    FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_FALSE );   I810_FIREVERTICES(imesa);   I810_STATECHANGE(imesa, I810_UPLOAD_BUFFERS);   if (front)   {     imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->fbOffset |					     imesa->i810Screen->backPitchBits);     i810XMesaSetFrontClipRects( imesa );   }   else   {     imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->backOffset |					     imesa->i810Screen->backPitchBits);     i810XMesaSetBackClipRects( imesa );   }   /* We want to update the s/w rast state too so that r200SetBuffer()    * gets called.    */   _swrast_DrawBuffer(ctx, mode);}

static void i810PointSize( struct gl_context *ctx, GLfloat sz ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   /* AA, non-AA limits are same */   const int size = (int) CLAMP(ctx->Point.Size,                                ctx->Const.MinPointSize,                                ctx->Const.MaxPointSize);   imesa->LcsPointSize = 0;   if (size & 1) imesa->LcsPointSize |= LCS_LINEWIDTH_1_0;   if (size & 2) imesa->LcsPointSize |= LCS_LINEWIDTH_2_0;   if (imesa->reduced_primitive == GL_POINTS) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_3_0;      imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsPointSize;   }}

static void i810LineWidth( struct gl_context *ctx, GLfloat widthf ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   /* AA, non-AA limits are same */   const int width = (int) CLAMP(ctx->Line.Width,                                 ctx->Const.MinLineWidth,                                 ctx->Const.MaxLineWidth);   imesa->LcsLineWidth = 0;   if (width & 1) imesa->LcsLineWidth |= LCS_LINEWIDTH_1_0;   if (width & 2) imesa->LcsLineWidth |= LCS_LINEWIDTH_2_0;   if (imesa->reduced_primitive == GL_LINES) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_3_0;      imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsLineWidth;   }}

void i810DrawBuffer(struct gl_context *ctx, GLenum mode ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   int front = 0;     if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */      FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0]) {   case BUFFER_FRONT_LEFT:     front = 1;     break;   case BUFFER_BACK_LEFT:     front = 0;     break;   default:      FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   if ( imesa->sarea->pf_current_page == 1 )      front ^= 1;    FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_FALSE );   I810_FIREVERTICES(imesa);   I810_STATECHANGE(imesa, I810_UPLOAD_BUFFERS);   if (front)   {     imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->fbOffset |					     imesa->i810Screen->backPitchBits);     i810XMesaSetFrontClipRects( imesa );   }   else   {     imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->backOffset |					     imesa->i810Screen->backPitchBits);     i810XMesaSetBackClipRects( imesa );   }}

static GLboolean enable_tex_2d( struct gl_context *ctx, GLuint unit ){  i810ContextPtr imesa = I810_CONTEXT(ctx);  struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];  struct gl_texture_object *tObj = texUnit->_Current;  i810TextureObjectPtr t = (i810TextureObjectPtr)tObj->DriverData;  GLint log2Width, log2Height;  log2Width = tObj->Image[0][t->base.firstLevel]->WidthLog2;  log2Height = tObj->Image[0][t->base.firstLevel]->HeightLog2;  I810_STATECHANGE(imesa, (I810_UPLOAD_TEX0<<unit));  t->Setup[I810_TEXREG_MCS] |= MCS_NORMALIZED_COORDS | MCS_UPDATE_NORMALIZED;   t->Setup[I810_TEXREG_MI2] = (MI2_DIMENSIONS_ARE_LOG2 |			       (log2Height << MI2_HEIGHT_SHIFT) | log2Width);    return GL_TRUE;}

static void i810DepthFunc(struct gl_context *ctx, GLenum func){   i810ContextPtr imesa = I810_CONTEXT(ctx);   int zmode;   switch(func)  {   case GL_NEVER: zmode = LCS_Z_NEVER; break;   case GL_ALWAYS: zmode = LCS_Z_ALWAYS; break;   case GL_LESS: zmode = LCS_Z_LESS; break;   case GL_LEQUAL: zmode = LCS_Z_LEQUAL; break;   case GL_EQUAL: zmode = LCS_Z_EQUAL; break;   case GL_GREATER: zmode = LCS_Z_GREATER; break;   case GL_GEQUAL: zmode = LCS_Z_GEQUAL; break;   case GL_NOTEQUAL: zmode = LCS_Z_NOTEQUAL; break;   default: return;   }   I810_STATECHANGE(imesa, I810_UPLOAD_CTX);   imesa->Setup[I810_CTXREG_LCS] &= ~LCS_Z_MASK;   imesa->Setup[I810_CTXREG_LCS] |= zmode;}

/* ============================================================= * Culling - the i810 isn't quite as clean here as the rest of *           its interfaces, but it's not bad. */static void i810CullFaceFrontFace(struct gl_context *ctx, GLenum unused){   i810ContextPtr imesa = I810_CONTEXT(ctx);   GLuint mode = LCS_CULL_BOTH;   if (ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) {      mode = LCS_CULL_CW;      if (ctx->Polygon.CullFaceMode == GL_FRONT)	 mode ^= (LCS_CULL_CW ^ LCS_CULL_CCW);      if (ctx->Polygon.FrontFace != GL_CCW)	 mode ^= (LCS_CULL_CW ^ LCS_CULL_CCW);   }   imesa->LcsCullMode = mode;   if (ctx->Polygon.CullFlag)   {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK;      imesa->Setup[I810_CTXREG_LCS] |= mode;   }}

void i810ChooseVertexState( GLcontext *ctx ){   TNLcontext *tnl = TNL_CONTEXT(ctx);   i810ContextPtr imesa = I810_CONTEXT( ctx );   GLuint ind = I810_XYZW_BIT|I810_RGBA_BIT;   if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)      ind |= I810_SPEC_BIT;   if (ctx->Fog.Enabled)      ind |= I810_FOG_BIT;   if (ctx->Texture._EnabledUnits & 0x2)      /* unit 1 enabled */      ind |= I810_TEX1_BIT|I810_TEX0_BIT;   else if (ctx->Texture._EnabledUnits & 0x1)      /* unit 0 enabled */      ind |= I810_TEX0_BIT;   imesa->SetupIndex = ind;   if (I810_DEBUG & (DEBUG_VERTS|DEBUG_STATE))      i810PrintSetupFlags( __FUNCTION__, ind );   if (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED)) {      tnl->Driver.Render.Interp = i810_interp_extras;      tnl->Driver.Render.CopyPV = i810_copy_pv_extras;   } else {      tnl->Driver.Render.Interp = setup_tab[ind].interp;      tnl->Driver.Render.CopyPV = setup_tab[ind].copy_pv;   }   if (setup_tab[ind].vertex_format != imesa->Setup[I810_CTXREG_VF]) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_VF] = setup_tab[ind].vertex_format;      imesa->vertex_size = setup_tab[ind].vertex_size;   }}

static GLboolean enable_tex_common( struct gl_context *ctx, GLuint unit ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];   struct gl_texture_object *tObj = texUnit->_Current;   i810TextureObjectPtr t = (i810TextureObjectPtr)tObj->DriverData;   if (tObj->Image[0][tObj->BaseLevel]->Border > 0) {     return GL_FALSE;   }  /* Upload teximages (not pipelined)   */  if (t->base.dirty_images[0]) {    I810_FIREVERTICES(imesa);    i810SetTexImages( imesa, tObj );    if (!t->base.memBlock) {      return GL_FALSE;    }  }     /* Update state if this is a different texture object to last   * time.   */  if (imesa->CurrentTexObj[unit] != t) {    I810_STATECHANGE(imesa, (I810_UPLOAD_TEX0<<unit));    imesa->CurrentTexObj[unit] = t;    t->base.bound |= (1U << unit);        /* XXX: should be locked */    driUpdateTextureLRU( (driTextureObject *) t );  }    imesa->TexEnvImageFmt[unit] = tObj->Image[0][tObj->BaseLevel]->_BaseFormat;  return GL_TRUE;}

static void i810ColorMask(struct gl_context *ctx,			  GLboolean r, GLboolean g,			  GLboolean b, GLboolean a ){   i810ContextPtr imesa = I810_CONTEXT( ctx );   GLuint tmp = 0;   if (r && g && b) {      tmp = imesa->Setup[I810_CTXREG_B2] | B2_FB_WRITE_ENABLE;      FALLBACK( imesa, I810_FALLBACK_COLORMASK, GL_FALSE );   } else if (!r && !g && !b) {      tmp = imesa->Setup[I810_CTXREG_B2] & ~B2_FB_WRITE_ENABLE;      FALLBACK( imesa, I810_FALLBACK_COLORMASK, GL_FALSE );   } else {      FALLBACK( imesa, I810_FALLBACK_COLORMASK, GL_TRUE );      return;   }   if (tmp != imesa->Setup[I810_CTXREG_B2]) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_B2] = tmp;      imesa->dirty |= I810_UPLOAD_CTX;   }}

static void i810TexParameter( GLcontext *ctx, GLenum target,			      struct gl_texture_object *tObj,			      GLenum pname, const GLfloat *params ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   i810TextureObjectPtr t = (i810TextureObjectPtr) tObj->DriverData;   if (!t)      return;   if ( target != GL_TEXTURE_2D )      return;   /* Can't do the update now as we don't know whether to flush    * vertices or not.  Setting imesa->new_state means that    * i810UpdateTextureState() will be called before any triangles are    * rendered.  If a statechange has occurred, it will be detected at    * that point, and buffered vertices flushed.      */   switch (pname) {   case GL_TEXTURE_MIN_FILTER:   case GL_TEXTURE_MAG_FILTER:      {         GLfloat bias = ctx->Texture.Unit[ctx->Texture.CurrentUnit].LodBias;         i810SetTexFilter( imesa, t, tObj->MinFilter, tObj->MagFilter, bias );      }      break;   case GL_TEXTURE_WRAP_S:   case GL_TEXTURE_WRAP_T:      i810SetTexWrapping( t, tObj->WrapS, tObj->WrapT );      break;     case GL_TEXTURE_BORDER_COLOR:      i810SetTexBorderColor( t, tObj->_BorderChan );      break;   case GL_TEXTURE_BASE_LEVEL:   case GL_TEXTURE_MAX_LEVEL:   case GL_TEXTURE_MIN_LOD:   case GL_TEXTURE_MAX_LOD:      /* This isn't the most efficient solution but there doesn't appear to       * be a nice alternative for Radeon.  Since there's no LOD clamping,       * we just have to rely on loading the right subset of mipmap levels       * to simulate a clamped LOD.       */      I810_FIREVERTICES( I810_CONTEXT(ctx) );      driSwapOutTextureObject( (driTextureObject *) t );      break;   default:      return;   }   if (t == imesa->CurrentTexObj[0]) {      I810_STATECHANGE( imesa, I810_UPLOAD_TEX0 );   }   if (t == imesa->CurrentTexObj[1]) {      I810_STATECHANGE( imesa, I810_UPLOAD_TEX1 );   }}

/* ============================================================= */static void i810Enable(struct gl_context *ctx, GLenum cap, GLboolean state){   i810ContextPtr imesa = I810_CONTEXT(ctx);   switch(cap) {   case GL_ALPHA_TEST:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_B1] &= ~B1_ALPHA_TEST_ENABLE;      if (state)	 imesa->Setup[I810_CTXREG_B1] |= B1_ALPHA_TEST_ENABLE;      break;   case GL_BLEND:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_B1] &= ~B1_BLEND_ENABLE;      if (state)	 imesa->Setup[I810_CTXREG_B1] |= B1_BLEND_ENABLE;      /* For some reason enable(GL_BLEND) affects ColorLogicOpEnabled.       */      FALLBACK( imesa, I810_FALLBACK_LOGICOP,		(ctx->Color.ColorLogicOpEnabled &&		 ctx->Color.LogicOp != GL_COPY));      break;   case GL_DEPTH_TEST:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_B1] &= ~B1_Z_TEST_ENABLE;      if (state)	 imesa->Setup[I810_CTXREG_B1] |= B1_Z_TEST_ENABLE;      break;   case GL_SCISSOR_TEST:      /* XXX without these next two lines, conform's scissor test fails */      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      I810_STATECHANGE(imesa, I810_UPLOAD_BUFFERS);      I810_FIREVERTICES(imesa);	/* don't pipeline cliprect changes */      imesa->upload_cliprects = GL_TRUE;      imesa->scissor = state;      break;   case GL_POLYGON_STIPPLE:      if (imesa->stipple_in_hw && imesa->reduced_primitive == GL_TRIANGLES)      {	 I810_STATECHANGE(imesa, I810_UPLOAD_CTX);	 imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE;	 if (state)	    imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE;      }      break;   case GL_LINE_SMOOTH:      /* Need to fatten the lines by .5, or they disappear...       */      if (imesa->reduced_primitive == GL_LINES) {	 I810_STATECHANGE(imesa, I810_UPLOAD_CTX);	 imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE;	 imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_0_5;	 if (state) {	    imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE;	    imesa->Setup[I810_CTXREG_LCS] |= LCS_LINEWIDTH_0_5;	 }      }      break;   case GL_POINT_SMOOTH:      if (imesa->reduced_primitive == GL_POINTS) {	 I810_STATECHANGE(imesa, I810_UPLOAD_CTX);	 imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE;	 imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_0_5;	 if (state) {	    imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE;	    imesa->Setup[I810_CTXREG_LCS] |= LCS_LINEWIDTH_0_5;	 }      }      break;   case GL_POLYGON_SMOOTH:      if (imesa->reduced_primitive == GL_TRIANGLES) {	 I810_STATECHANGE(imesa, I810_UPLOAD_CTX);	 imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE;	 if (state)	    imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE;      }      break;   case GL_FOG:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_B1] &= ~B1_FOG_ENABLE;      if (state)	 imesa->Setup[I810_CTXREG_B1] |= B1_FOG_ENABLE;      break;   case GL_CULL_FACE:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK;      if (state)	 imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsCullMode;      else	 imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE;      break;   case GL_TEXTURE_2D:   case GL_TEXTURE_RECTANGLE_NV:      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      if (ctx->Texture.CurrentUnit == 0) {	 imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL0_ENABLE;	 if (state)//.........这里部分代码省略.........

static void i810BlendFuncSeparate( struct gl_context *ctx, GLenum sfactorRGB,				     GLenum dfactorRGB, GLenum sfactorA,				     GLenum dfactorA ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   GLuint a = SDM_UPDATE_SRC_BLEND | SDM_UPDATE_DST_BLEND;   GLboolean fallback = GL_FALSE;   switch (ctx->Color.Blend[0].SrcRGB) {   case GL_ZERO:                a |= SDM_SRC_ZERO; break;   case GL_ONE:                 a |= SDM_SRC_ONE; break;   case GL_SRC_COLOR:           a |= SDM_SRC_SRC_COLOR; break;   case GL_ONE_MINUS_SRC_COLOR: a |= SDM_SRC_INV_SRC_COLOR; break;   case GL_SRC_ALPHA:           a |= SDM_SRC_SRC_ALPHA; break;   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_SRC_INV_SRC_ALPHA; break;   case GL_DST_ALPHA:           a |= SDM_SRC_ONE; break;   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_SRC_ZERO; break;   case GL_DST_COLOR:           a |= SDM_SRC_DST_COLOR; break;   case GL_ONE_MINUS_DST_COLOR: a |= SDM_SRC_INV_DST_COLOR; break;   /* (f, f, f, 1), f = min(As, 1 - Ad) = min(As, 1 - 1) = 0    * So (f, f, f, 1) = (0, 0, 0, 1).  Since there is no destination alpha and    * the only supported alpha operation is GL_FUNC_ADD, the result modulating    * the source alpha with the alpha factor is largely irrelevant.    */   case GL_SRC_ALPHA_SATURATE:  a |= SDM_SRC_ZERO; break;   case GL_CONSTANT_COLOR:   case GL_ONE_MINUS_CONSTANT_COLOR:   case GL_CONSTANT_ALPHA:   case GL_ONE_MINUS_CONSTANT_ALPHA:      fallback = GL_TRUE;      break;   default:      return;   }   switch (ctx->Color.Blend[0].DstRGB) {   case GL_ZERO:                a |= SDM_DST_ZERO; break;   case GL_ONE:                 a |= SDM_DST_ONE; break;   case GL_SRC_COLOR:           a |= SDM_DST_SRC_COLOR; break;   case GL_ONE_MINUS_SRC_COLOR: a |= SDM_DST_INV_SRC_COLOR; break;   case GL_SRC_ALPHA:           a |= SDM_DST_SRC_ALPHA; break;   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_DST_INV_SRC_ALPHA; break;   case GL_DST_ALPHA:           a |= SDM_DST_ONE; break;   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_DST_ZERO; break;   case GL_DST_COLOR:           a |= SDM_DST_DST_COLOR; break;   case GL_ONE_MINUS_DST_COLOR: a |= SDM_DST_INV_DST_COLOR; break;   case GL_CONSTANT_COLOR:   case GL_ONE_MINUS_CONSTANT_COLOR:   case GL_CONSTANT_ALPHA:   case GL_ONE_MINUS_CONSTANT_ALPHA:      fallback = GL_TRUE;      break;   default:      return;   }   FALLBACK( imesa, I810_FALLBACK_BLEND_FUNC, fallback);   if (!fallback) {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->Setup[I810_CTXREG_SDM] &= ~(SDM_SRC_MASK|SDM_DST_MASK);      imesa->Setup[I810_CTXREG_SDM] |= a;   }}

/* System to flush dma and emit state changes based on the rasterized * primitive. */void i810RasterPrimitive( GLcontext *ctx,			  GLenum rprim,			  GLuint hwprim ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   GLuint st1 = imesa->Setup[I810_CTXREG_ST1];   GLuint aa = imesa->Setup[I810_CTXREG_AA];   GLuint lcs = imesa->Setup[I810_CTXREG_LCS];   st1 &= ~ST1_ENABLE;   aa &= ~AA_ENABLE;   if (I810_DEBUG & DEBUG_PRIMS) {      /* Prints reduced prim, and hw prim */      char *prim_name = "Unknown";            switch(hwprim) {      case PR_LINES:	 prim_name = "Lines";	 break;      case PR_LINESTRIP:	 prim_name = "LineStrip";	 break;	       case PR_TRIANGLES:	 prim_name = "Triangles";	 break;	       case PR_TRISTRIP_0:	 prim_name = "TriStrip_0";	 break;	       case PR_TRIFAN:	 prim_name = "TriFan";	 break;	       case PR_POLYGON:	 prim_name = "Polygons";	 break;      default:	 break;      }      fprintf(stderr, "%s : rprim(%s), hwprim(%s)/n",	      __FUNCTION__,	      _mesa_lookup_enum_by_nr(rprim),	      prim_name);   }   switch (rprim) {   case GL_TRIANGLES:      if (ctx->Polygon.StippleFlag)	 st1 |= ST1_ENABLE;      if (ctx->Polygon.SmoothFlag)	 aa |= AA_ENABLE;      break;   case GL_LINES:      lcs &= ~(LCS_LINEWIDTH_3_0|LCS_LINEWIDTH_0_5);      lcs |= imesa->LcsLineWidth;      if (ctx->Line.SmoothFlag) {	 aa |= AA_ENABLE;	 lcs |= LCS_LINEWIDTH_0_5;      }      break;   case GL_POINTS:      lcs &= ~(LCS_LINEWIDTH_3_0|LCS_LINEWIDTH_0_5);      lcs |= imesa->LcsPointSize;      if (ctx->Point.SmoothFlag) {	 aa |= AA_ENABLE;	 lcs |= LCS_LINEWIDTH_0_5;      }      break;   default:      return;   }   imesa->reduced_primitive = rprim;   if (st1 != imesa->Setup[I810_CTXREG_ST1] ||       aa != imesa->Setup[I810_CTXREG_AA] ||       lcs != imesa->Setup[I810_CTXREG_LCS])   {      I810_STATECHANGE(imesa, I810_UPLOAD_CTX);      imesa->hw_primitive = hwprim;      imesa->Setup[I810_CTXREG_LCS] = lcs;      imesa->Setup[I810_CTXREG_ST1] = st1;      imesa->Setup[I810_CTXREG_AA] = aa;   }   else if (hwprim != imesa->hw_primitive) {      I810_STATECHANGE(imesa, 0);      imesa->hw_primitive = hwprim;   }}