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

/** * Update hardware state for a texture unit. * * /todo * 1D textures should be supported!  Just use a 2D texture with the second * texture coordinate value fixed at 0.0. */static void i810UpdateTexUnit( struct gl_context *ctx, GLuint unit, 			      int * next_color_stage, int * next_alpha_stage ){   i810ContextPtr imesa = I810_CONTEXT(ctx);   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];   GLboolean ret;      switch(texUnit->_ReallyEnabled) {   case TEXTURE_2D_BIT:     ret = enable_tex_common( ctx, unit);     ret &= enable_tex_2d(ctx, unit);     if (ret == GL_FALSE) {       FALLBACK( imesa, I810_FALLBACK_TEXTURE, GL_TRUE );     }     break;   case TEXTURE_RECT_BIT:     ret = enable_tex_common( ctx, unit);     ret &= enable_tex_rect(ctx, unit);     if (ret == GL_FALSE) {       FALLBACK( imesa, I810_FALLBACK_TEXTURE, GL_TRUE );     }     break;   case 0:     disable_tex(ctx, unit);     break;   }   if (!i810UpdateTexEnvCombine( ctx, unit, 				 next_color_stage, next_alpha_stage )) {     FALLBACK( imesa, I810_FALLBACK_TEXTURE, GL_TRUE );   }   return;}

static void updateTextureUnit( struct gl_context *ctx, int unit ){   sisContextPtr smesa = SIS_CONTEXT( ctx );   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];   struct gl_texture_object *texObj = texUnit->_Current;   GLint fallbackbit;      if (unit == 0)      fallbackbit = SIS_FALLBACK_TEXTURE0;   else      fallbackbit = SIS_FALLBACK_TEXTURE1;   if (texUnit->_ReallyEnabled & (TEXTURE_1D_BIT | TEXTURE_2D_BIT)) {      if (smesa->TexStates[unit] & NEW_TEXTURING) {         GLboolean ok;         ok = sis_set_texobj_parm (ctx, texObj, unit);         FALLBACK( smesa, fallbackbit, !ok );      }      if (smesa->TexStates[unit] & NEW_TEXTURE_ENV) {         if (unit == 0)            sis_set_texture_env0( ctx, texObj, unit );         else            sis_set_texture_env1( ctx, texObj, unit );      }      smesa->TexStates[unit] = 0;   } else if ( texUnit->_ReallyEnabled ) {      /* fallback */      FALLBACK( smesa, fallbackbit, 1 );   } else {      sis_reset_texture_env( ctx, unit );      FALLBACK( smesa, fallbackbit, 0 );   }}

/* XXX support for separate read/draw buffers hasn't been tested */static void tdfxDDDrawBuffer( GLcontext *ctx, GLenum mode ){   tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);   if ( TDFX_DEBUG & DEBUG_VERBOSE_API ) {      fprintf( stderr, "%s()/n", __FUNCTION__ );   }   FLUSH_BATCH( fxMesa );   if (ctx->DrawBuffer->_NumColorDrawBuffers > 1) {      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {   case BUFFER_FRONT_LEFT:      fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_FRONTBUFFER;      fxMesa->new_state |= TDFX_NEW_RENDER;      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case BUFFER_BACK_LEFT:      fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_BACKBUFFER;      fxMesa->new_state |= TDFX_NEW_RENDER;      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case -1:      FX_grColorMaskv( ctx, false4 );      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_TRUE );      break;   }}

static void mgaDDDrawBuffer(GLcontext *ctx, GLenum mode ){   mgaContextPtr mmesa = MGA_CONTEXT(ctx);   FLUSH_BATCH( mmesa );   /*    * _DrawDestMask is easier to cope with than <mode>.    */   switch ( ctx->Color._DrawDestMask[0] ) {   case DD_FRONT_LEFT_BIT:      mmesa->setup.dstorg = mmesa->mgaScreen->frontOffset;      mmesa->dirty |= MGA_UPLOAD_CONTEXT;      mmesa->draw_buffer = MGA_FRONT;      mgaXMesaSetFrontClipRects( mmesa );      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case DD_BACK_LEFT_BIT:      mmesa->setup.dstorg = mmesa->mgaScreen->backOffset;      mmesa->draw_buffer = MGA_BACK;      mmesa->dirty |= MGA_UPLOAD_CONTEXT;      mgaXMesaSetBackClipRects( mmesa );      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   /* We want to update the s/w rast state too so that r200SetBuffer()    * gets called.    */   _swrast_DrawBuffer(ctx, mode);}

static void mgaDDDrawBuffer(GLcontext *ctx, GLenum mode ){   mgaContextPtr mmesa = MGA_CONTEXT(ctx);   FLUSH_BATCH( mmesa );   /*    * _DrawDestMask is easier to cope with than <mode>.    */   switch ( ctx->DrawBuffer->_ColorDrawBufferMask[0] ) {   case BUFFER_BIT_FRONT_LEFT:      mmesa->setup.dstorg = mmesa->mgaScreen->frontOffset;      mmesa->dirty |= MGA_UPLOAD_CONTEXT;      mmesa->draw_buffer = MGA_FRONT;      mgaXMesaSetFrontClipRects( mmesa );      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case BUFFER_BIT_BACK_LEFT:      mmesa->setup.dstorg = mmesa->mgaScreen->backOffset;      mmesa->draw_buffer = MGA_BACK;      mmesa->dirty |= MGA_UPLOAD_CONTEXT;      mgaXMesaSetBackClipRects( mmesa );      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }}

static void gammaUpdateTexUnit( GLcontext *ctx, GLuint unit ){   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];   /* fprintf(stderr, "%s/n", __FUNCTION__);  */   if (texUnit->_ReallyEnabled == TEXTURE_2D_BIT)    {      struct gl_texture_object *tObj = texUnit->_Current;      gammaTextureObjectPtr t = (gammaTextureObjectPtr)tObj->DriverData;      /* Upload teximages (not pipelined)       */      if (t->dirty_images) {	 gammaSetTexImages( gmesa, tObj );	 if (!t->MemBlock) {	    FALLBACK( gmesa, GAMMA_FALLBACK_TEXTURE, GL_TRUE );	    return;	 }      }#if 0      if (tObj->Image[0][tObj->BaseLevel]->Border > 0) {         FALLBACK( gmesa, GAMMA_FALLBACK_TEXTURE, GL_TRUE );         return;      }#endif      /* Update state if this is a different texture object to last       * time.       */      if (gmesa->CurrentTexObj[unit] != t) {	 gmesa->dirty |= GAMMA_UPLOAD_TEX0 /* << unit */;	 gmesa->CurrentTexObj[unit] = t;	 gammaUpdateTexLRU( gmesa, t ); /* done too often */      }            /* Update texture environment if texture object image format or        * texture environment state has changed.       */      if (tObj->Image[0][tObj->BaseLevel]->Format != gmesa->TexEnvImageFmt[unit]) {	 gmesa->TexEnvImageFmt[unit] = tObj->Image[0][tObj->BaseLevel]->Format;	 gammaUpdateTexEnv( ctx, unit );      }   }   else if (texUnit->_ReallyEnabled) {      FALLBACK( gmesa, GAMMA_FALLBACK_TEXTURE, GL_TRUE );   }   else /*if (gmesa->CurrentTexObj[unit])*/ {      gmesa->CurrentTexObj[unit] = 0;      gmesa->TexEnvImageFmt[unit] = 0;	      gmesa->dirty &= ~(GAMMA_UPLOAD_TEX0<<unit);    }}

static void sis6326DDColorMask( GLcontext *ctx,				GLboolean r, GLboolean g,				GLboolean b, GLboolean a ){   sisContextPtr smesa = SIS_CONTEXT(ctx);	   if (r && g && b && ((ctx->Visual.alphaBits == 0) || a)) {      FALLBACK(smesa, SIS_FALLBACK_WRITEMASK, 0);   } else {      FALLBACK(smesa, SIS_FALLBACK_WRITEMASK, 1);   }}

static void i810BlendEquationSeparate(struct gl_context *ctx,				      GLenum modeRGB, GLenum modeA){   assert( modeRGB == modeA );   /* Can only do GL_ADD equation in hardware */   FALLBACK( I810_CONTEXT(ctx), I810_FALLBACK_BLEND_EQ, 	     modeRGB != GL_FUNC_ADD);   /* BlendEquation sets ColorLogicOpEnabled in an unexpected    * manner.    */   FALLBACK( I810_CONTEXT(ctx), I810_FALLBACK_LOGICOP,	     (ctx->Color.ColorLogicOpEnabled &&	      ctx->Color.LogicOp != GL_COPY));}

static void mgaDDDepthFunc(GLcontext *ctx, GLenum func){   mgaContextPtr mmesa = MGA_CONTEXT( ctx );   int zmode;   switch (func) {   case GL_NEVER:      /* can't do this in h/w, we'll use a s/w fallback */      FALLBACK (ctx, MGA_FALLBACK_DEPTH, ctx->Depth.Test);      /* FALLTHROUGH */   case GL_ALWAYS:      zmode = DC_zmode_nozcmp; break;   case GL_LESS:      zmode = DC_zmode_zlt; break;   case GL_LEQUAL:      zmode = DC_zmode_zlte; break;   case GL_EQUAL:      zmode = DC_zmode_ze; break;   case GL_GREATER:      zmode = DC_zmode_zgt; break;   case GL_GEQUAL:      zmode = DC_zmode_zgte; break;   case GL_NOTEQUAL:      zmode = DC_zmode_zne; break;   default:      zmode = 0; break;   }   MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );   mmesa->hw.zmode &= DC_zmode_MASK;   mmesa->hw.zmode |= zmode;}

static void tdfxDDColorMask( GLcontext *ctx,			     GLboolean r, GLboolean g,			     GLboolean b, GLboolean a ){   tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);   FLUSH_BATCH( fxMesa );   if ( fxMesa->Color.ColorMask[RCOMP] != r ||	fxMesa->Color.ColorMask[GCOMP] != g ||	fxMesa->Color.ColorMask[BCOMP] != b ||	fxMesa->Color.ColorMask[ACOMP] != a ) {      fxMesa->Color.ColorMask[RCOMP] = r;      fxMesa->Color.ColorMask[GCOMP] = g;      fxMesa->Color.ColorMask[BCOMP] = b;      fxMesa->Color.ColorMask[ACOMP] = a;      fxMesa->dirty |= TDFX_UPLOAD_COLOR_MASK;      if (ctx->Visual.redBits < 8) {         /* Can't do RGB colormasking in 16bpp mode. */         /* We can completely ignore the alpha mask. */	 FALLBACK( fxMesa, TDFX_FALLBACK_COLORMASK, (r != g || g != b) );      }   }}

void r128UpdateTextureState( GLcontext *ctx ){   r128ContextPtr rmesa = R128_CONTEXT(ctx);   GLboolean ok;   /* This works around a quirk with the R128 hardware.  If only OpenGL     * TEXTURE1 is enabled, then the hardware TEXTURE0 must be used.  The    * hardware TEXTURE1 can ONLY be used when hardware TEXTURE0 is also used.    */   rmesa->tmu_source[0] = 0;   rmesa->tmu_source[1] = 1;   if ((ctx->Texture._EnabledUnits & 0x03) == 0x02) {      /* only texture 1 enabled */      rmesa->tmu_source[0] = 1;      rmesa->tmu_source[1] = 0;   }   ok = (updateTextureUnit( ctx, 0 ) &&	 updateTextureUnit( ctx, 1 ));   FALLBACK( rmesa, R128_FALLBACK_TEXTURE, !ok );}

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);}

gboolean tm_tags_equal(const TMTag *a, const TMTag *b){	if (a == b)		return TRUE;	return (a->line == b->line &&			a->file == b->file /* ptr comparison */ &&			strcmp(FALLBACK(a->name, ""), FALLBACK(b->name, "")) == 0 &&			a->type == b->type &&			a->local == b->local &&			a->pointerOrder == b->pointerOrder &&			a->access == b->access &&			a->impl == b->impl &&			a->lang == b->lang &&			strcmp(FALLBACK(a->scope, ""), FALLBACK(b->scope, "")) == 0 &&			strcmp(FALLBACK(a->arglist, ""), FALLBACK(b->arglist, "")) == 0 &&			strcmp(FALLBACK(a->inheritance, ""), FALLBACK(b->inheritance, "")) == 0 &&			strcmp(FALLBACK(a->var_type, ""), FALLBACK(b->var_type, "")) == 0);}

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 );   }}

void sis6326DDDrawBuffer( GLcontext *ctx, GLenum mode ){   sisContextPtr smesa = SIS_CONTEXT(ctx);   __GLSiSHardware *prev = &smesa->prev;   __GLSiSHardware *current = &smesa->current;   if(getenv("SIS_DRAW_FRONT"))      ctx->DrawBuffer->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;   if (ctx->DrawBuffer->_NumColorDrawBuffers > 1) {      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   current->hwDstSet &= ~MASK_DstBufferPitch;   switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {   case BUFFER_FRONT_LEFT:      current->hwOffsetDest = smesa->front.offset;      current->hwDstSet |= smesa->front.pitch;      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case BUFFER_BACK_LEFT:      current->hwOffsetDest = smesa->back.offset;      current->hwDstSet |= smesa->back.pitch;      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   if (current->hwDstSet != prev->hwDstSet) {      prev->hwDstSet = current->hwDstSet;      smesa->GlobalFlag |= GFLAG_DESTSETTING;   }   if (current->hwOffsetDest != prev->hwOffsetDest) {      prev->hwOffsetDest = current->hwOffsetDest;      smesa->GlobalFlag |= GFLAG_DESTSETTING;   }}

void gammaUpdateTextureState( GLcontext *ctx ){   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);   /* fprintf(stderr, "%s/n", __FUNCTION__);  */   FALLBACK( gmesa, GAMMA_FALLBACK_TEXTURE, GL_FALSE );   gammaUpdateTexUnit( ctx, 0 );#if 0   gammaUpdateTexUnit( ctx, 1 );#endif}

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;   }}

static void tdfxDDLightModelfv( GLcontext *ctx, GLenum pname,				const GLfloat *param ){   tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);   if ( pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {      FALLBACK( fxMesa, TDFX_FALLBACK_SPECULAR,		(ctx->Light.Enabled &&		 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ));   }}

/* Update the hardware texture state */void mach64UpdateTextureState( GLcontext *ctx ){   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);   if ( MACH64_DEBUG & DEBUG_VERBOSE_API ) {      fprintf( stderr, "%s( %p ) en=0x%x 0x%x/n",	       __FUNCTION__, ctx, ctx->Texture.Unit[0]._ReallyEnabled,	       ctx->Texture.Unit[1]._ReallyEnabled);   }   /* Clear any texturing fallbacks */   FALLBACK( mmesa, MACH64_FALLBACK_TEXTURE, GL_FALSE );   /* Unbind any currently bound textures */   if ( mmesa->CurrentTexObj[0] ) mmesa->CurrentTexObj[0]->base.bound = 0;   if ( mmesa->CurrentTexObj[1] ) mmesa->CurrentTexObj[1]->base.bound = 0;   mmesa->CurrentTexObj[0] = NULL;   mmesa->CurrentTexObj[1] = NULL;   /* Disable all texturing until it is known to be good */   mmesa->setup.scale_3d_cntl  |=  MACH64_TEXTURE_DISABLE;   mmesa->setup.scale_3d_cntl  &= ~MACH64_TEX_MAP_AEN;   mmesa->setup.tex_cntl       &= ~MACH64_TEXTURE_COMPOSITE;   mmesa->setup.tex_size_pitch = 0x00000000;   mmesa->tmu_source[0] = 0;   mmesa->tmu_source[1] = 1;   mmesa->multitex = 0;   if (ctx->Texture._EnabledUnits & 0x2) {       /* unit 1 enabled */       if (ctx->Texture._EnabledUnits & 0x1) {	  /* units 0 and 1 enabled */	  mmesa->multitex = 1;	  mach64UpdateTextureUnit( ctx, 0 );	  mach64UpdateTextureEnv( ctx, 0 );	  mach64UpdateTextureUnit( ctx, 1 );	  mach64UpdateTextureEnv( ctx, 1 );       } else {	  mmesa->tmu_source[0] = 1;	  mmesa->tmu_source[1] = 0;	  mach64UpdateTextureUnit( ctx, 0 );	  mach64UpdateTextureEnv( ctx, 0 );       }   } else if (ctx->Texture._EnabledUnits & 0x1) {      /* only unit 0 enabled */       mach64UpdateTextureUnit( ctx, 0 );      mach64UpdateTextureEnv( ctx, 0 );   }   mmesa->dirty |= (MACH64_UPLOAD_SCALE_3D_CNTL |		    MACH64_UPLOAD_TEXTURE);}

/* Seperate specular not fully implemented on the i810. */static void i810LightModelfv(struct gl_context *ctx, GLenum pname,			       const GLfloat *param){   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL)   {      i810ContextPtr imesa = I810_CONTEXT( ctx );      FALLBACK( imesa, I810_FALLBACK_SPECULAR,		(ctx->Light.Enabled &&		 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR));   }}

void sis6326DDDrawBuffer( GLcontext *ctx, GLenum mode ){   sisContextPtr smesa = SIS_CONTEXT(ctx);   __GLSiSHardware *prev = &smesa->prev;   __GLSiSHardware *current = &smesa->current;   if(getenv("SIS_DRAW_FRONT"))      ctx->DrawBuffer->_ColorDrawBufferMask[0] = GL_FRONT_LEFT;   /*    * _DrawDestMask is easier to cope with than <mode>.    */   current->hwDstSet &= ~MASK_DstBufferPitch;   switch ( ctx->DrawBuffer->_ColorDrawBufferMask[0] ) {   case BUFFER_BIT_FRONT_LEFT:      current->hwOffsetDest = smesa->front.offset;      current->hwDstSet |= smesa->front.pitch;      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case BUFFER_BIT_BACK_LEFT:      current->hwOffsetDest = smesa->back.offset;      current->hwDstSet |= smesa->back.pitch;      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */      FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );      return;   }   if (current->hwDstSet != prev->hwDstSet) {      prev->hwDstSet = current->hwDstSet;      smesa->GlobalFlag |= GFLAG_DESTSETTING;   }   if (current->hwOffsetDest != prev->hwOffsetDest) {      prev->hwOffsetDest = current->hwOffsetDest;      smesa->GlobalFlag |= GFLAG_DESTSETTING;   }}

void i915UpdateTextureState( intelContextPtr intel ){   GLcontext *ctx = &intel->ctx;   GLboolean ok = GL_TRUE;   GLuint i;   for (i = 0 ; i < I915_TEX_UNITS && ok ; i++) {      ok = i915UpdateTexUnit( ctx, i );   }   FALLBACK( intel, I915_FALLBACK_TEXTURE, !ok );}

static void updateBlendLogicOp(GLcontext *ctx){   mgaContextPtr mmesa = MGA_CONTEXT(ctx);   MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );   mmesa->hw.blend_func_enable =      (ctx->Color.BlendEnabled && !ctx->Color._LogicOpEnabled) ? ~0 : 0;   FALLBACK( ctx, MGA_FALLBACK_BLEND,             ctx->Color.BlendEnabled && !ctx->Color._LogicOpEnabled &&             mmesa->hw.blend_func == (AC_src_src_alpha_sat | AC_dst_zero) );}

voidi915_upload_program(struct i915_context *i915,                    struct i915_fragment_program *p){   GLuint program_size = p->csr - p->program;   GLuint decl_size = p->decl - p->declarations;   FALLBACK(&i915->intel, I915_FALLBACK_PROGRAM, p->error);   /* Could just go straight to the batchbuffer from here:    */   if (i915->state.ProgramSize != (program_size + decl_size) ||       memcmp(i915->state.Program + decl_size, p->program,              program_size * sizeof(int)) != 0) {      I915_STATECHANGE(i915, I915_UPLOAD_PROGRAM);      memcpy(i915->state.Program, p->declarations, decl_size * sizeof(int));      memcpy(i915->state.Program + decl_size, p->program,             program_size * sizeof(int));      i915->state.ProgramSize = decl_size + program_size;   }   /* Always seemed to get a failure if I used memcmp() to    * shortcircuit this state upload.  Needs further investigation?    */   if (p->nr_constants) {      GLuint nr = p->nr_constants;      I915_ACTIVESTATE(i915, I915_UPLOAD_CONSTANTS, 1);      I915_STATECHANGE(i915, I915_UPLOAD_CONSTANTS);      i915->state.Constant[0] = _3DSTATE_PIXEL_SHADER_CONSTANTS | ((nr) * 4);      i915->state.Constant[1] = (1 << (nr - 1)) | ((1 << (nr - 1)) - 1);      memcpy(&i915->state.Constant[2], p->constant, 4 * sizeof(int) * (nr));      i915->state.ConstantSize = 2 + (nr) * 4;      if (0) {         GLuint i;         for (i = 0; i < nr; i++) {            fprintf(stderr, "const[%d]: %f %f %f %f/n", i,                    p->constant[i][0],                    p->constant[i][1], p->constant[i][2], p->constant[i][3]);         }      }   }   else {      I915_ACTIVESTATE(i915, I915_UPLOAD_CONSTANTS, 0);   }   p->on_hardware = 1;}

/* XXX support for separate read/draw buffers hasn't been tested */static void tdfxDDDrawBuffer( GLcontext *ctx, GLenum mode ){   tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);   if ( TDFX_DEBUG & DEBUG_VERBOSE_API ) {      fprintf( stderr, "%s()/n", __FUNCTION__ );   }   FLUSH_BATCH( fxMesa );   /*    * _DrawDestMask is easier to cope with than <mode>.    */   switch ( ctx->Color._DrawDestMask[0] ) {   case DD_FRONT_LEFT_BIT:      fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_FRONTBUFFER;      fxMesa->new_state |= TDFX_NEW_RENDER;      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case DD_BACK_LEFT_BIT:      fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_BACKBUFFER;      fxMesa->new_state |= TDFX_NEW_RENDER;      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   case 0:      FX_grColorMaskv( ctx, false4 );      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_FALSE );      break;   default:      FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_TRUE );      break;   }   /* We want to update the s/w rast state too so that tdfxDDSetBuffer()    * gets called.    */   _swrast_DrawBuffer(ctx, mode);}

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 voidi915PointParameterfv(struct gl_context * ctx, GLenum pname, const GLfloat *params){   struct i915_context *i915 = I915_CONTEXT(ctx);   switch (pname) {   case GL_POINT_SPRITE_COORD_ORIGIN:      /* This could be supported, but it would require modifying the fragment       * program to invert the y component of the texture coordinate by       * inserting a 'SUB tc.y, {1.0}.xxxx, tc' instruction.       */      FALLBACK(&i915->intel, I915_FALLBACK_POINT_SPRITE_COORD_ORIGIN,	       (params[0] != GL_UPPER_LEFT));      break;   }}

void intelInitBatchBuffer( GLcontext *ctx ){   intelContextPtr intel = INTEL_CONTEXT(ctx);   if (!intel->intelScreen->allow_batchbuffer || getenv("INTEL_NO_BATCH")) {      intel->alloc.size = 8 * 1024;      intel->alloc.ptr = malloc( intel->alloc.size );      intel->alloc.offset = 0;   }   else {      switch (intel->intelScreen->deviceID) {      case PCI_CHIP_I865_G:	 /* HW bug?  Seems to crash if batchbuffer crosses 4k boundary.	  */	 intel->alloc.size = 8 * 1024; 	 break;      default:	 /* This is the smallest amount of memory the kernel deals with.	  * We'd ideally like to make this smaller.	  */	 intel->alloc.size = 1 << intel->intelScreen->logTextureGranularity;	 break;      }      intel->alloc.ptr = intelAllocateAGP( intel, intel->alloc.size );      if (intel->alloc.ptr)	 intel->alloc.offset = 	    intelAgpOffsetFromVirtual( intel, intel->alloc.ptr );   }   if (!intel->alloc.ptr) {      FALLBACK(intel, INTEL_FALLBACK_NO_BATCHBUFFER, 1);   }   else {      intel->prim.flush = 0;      intel->vtbl.emit_invarient_state( intel );      /* Make sure this gets to the hardware, even if we have no cliprects:       */      LOCK_HARDWARE( intel );      intelFlushBatchLocked( intel, GL_TRUE, GL_FALSE, GL_TRUE );      UNLOCK_HARDWARE( intel );   }}

voidi915_update_sprite_point_enable(struct gl_context *ctx){   struct intel_context *intel = intel_context(ctx);   /* _NEW_PROGRAM */   struct i915_fragment_program *p =      (struct i915_fragment_program *) ctx->FragmentProgram._Current;   const GLbitfield64 inputsRead = p->FragProg.Base.InputsRead;   struct i915_context *i915 = i915_context(ctx);   GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK;   int i;   GLuint coord_replace_bits = 0x0;   GLuint tex_coord_unit_bits = 0x0;   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {      /* _NEW_POINT */      if (ctx->Point.CoordReplace[i] && ctx->Point.PointSprite)         coord_replace_bits |= (1 << i);      if (inputsRead & FRAG_BIT_TEX(i))         tex_coord_unit_bits |= (1 << i);   }   /*    * Here we can't enable the SPRITE_POINT_ENABLE bit when the mis-match    * of tex_coord_unit_bits and coord_replace_bits, or this will make all    * the other non-point-sprite coords(like varying inputs, as we now use    * tex coord to implement varying inputs) be replaced to value (0, 0)-(1, 1).    *    * Thus, do fallback when needed.    */   FALLBACK(intel, I915_FALLBACK_COORD_REPLACE,            coord_replace_bits && coord_replace_bits != tex_coord_unit_bits);   s4 &= ~S4_SPRITE_POINT_ENABLE;   s4 |= (coord_replace_bits && coord_replace_bits == tex_coord_unit_bits) ?         S4_SPRITE_POINT_ENABLE : 0;   if (s4 != i915->state.Ctx[I915_CTXREG_LIS4]) {      i915->state.Ctx[I915_CTXREG_LIS4] = s4;      I915_STATECHANGE(i915, I915_UPLOAD_CTX);   }}

voidi830UpdateTextureState(struct intel_context *intel){   struct i830_context *i830 = i830_context(&intel->ctx);   GLboolean ok = GL_TRUE;   GLuint i;   for (i = 0; i < I830_TEX_UNITS && ok; i++) {      switch (intel->ctx.Texture.Unit[i]._ReallyEnabled) {      case TEXTURE_1D_BIT:      case TEXTURE_2D_BIT:      case TEXTURE_CUBE_BIT:         ok = i830_update_tex_unit(intel, i, TEXCOORDS_ARE_NORMAL);         break;      case TEXTURE_RECT_BIT:         ok = i830_update_tex_unit(intel, i, TEXCOORDS_ARE_IN_TEXELUNITS);         break;      case 0:{	 struct i830_context *i830 = i830_context(&intel->ctx);         if (i830->state.active & I830_UPLOAD_TEX(i))             I830_ACTIVESTATE(i830, I830_UPLOAD_TEX(i), GL_FALSE);	 if (i830->state.tex_buffer[i] != NULL) {	    dri_bo_unreference(i830->state.tex_buffer[i]);	    i830->state.tex_buffer[i] = NULL;	 }         break;      }      case TEXTURE_3D_BIT:      default:         ok = GL_FALSE;         break;      }   }   FALLBACK(intel, I830_FALLBACK_TEXTURE, !ok);   if (ok)      i830EmitTextureBlend(i830);}