fxsetup.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

   grColorCombine(GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_NONE,
                  localc,
                  GR_COMBINE_OTHER_NONE,
                  FXFALSE);

   fxMesa->lastUnitsMode = FX_UM_NONE;
}

#include "fxsetup.h"

/************************************************************************/
/************************** Texture Mode SetUp **************************/
/************************************************************************/

static void
fxSetupTexture_NoLock(GLcontext * ctx)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);

   if (TDFX_DEBUG & VERBOSE_DRIVER) {
      fprintf(stderr, "fxSetupTexture_NoLock(...)\n");
   }

   if (fxMesa->HaveCmbExt) {
      /* Texture Combine, Color Combine and Alpha Combine. */
      if ((ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
          (ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
          fxMesa->haveTwoTMUs) {
         fxSetupTextureDoubleTMUNapalm_NoLock(ctx);
      }
      else if (ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
         fxSetupTextureSingleTMUNapalm_NoLock(ctx, 0);
      }
      else if (ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
         fxSetupTextureSingleTMUNapalm_NoLock(ctx, 1);
      }
      else {
         fxSetupTextureNoneNapalm_NoLock(ctx);
      }
   } else {
      /* Texture Combine, Color Combine and Alpha Combine. */
      if ((ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
          (ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
          fxMesa->haveTwoTMUs) {
         fxSetupTextureDoubleTMU_NoLock(ctx);
      }
      else if (ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
         fxSetupTextureSingleTMU_NoLock(ctx, 0);
      }
      else if (ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
         fxSetupTextureSingleTMU_NoLock(ctx, 1);
      }
      else {
         fxSetupTextureNone_NoLock(ctx);
      }
   }
}

void
fxSetupTexture(GLcontext * ctx)
{
   BEGIN_BOARD_LOCK();
   fxSetupTexture_NoLock(ctx);
   END_BOARD_LOCK();
}

/************************************************************************/
/**************************** Blend SetUp *******************************/
/************************************************************************/

void
fxDDBlendFuncSeparate(GLcontext * ctx, GLenum sfactor, GLenum dfactor, GLenum asfactor, GLenum adfactor)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;
   GLboolean isNapalm = (fxMesa->type >= GR_SSTTYPE_Voodoo4);
   GLboolean have32bpp = (fxMesa->colDepth == 32);
   GLboolean haveAlpha = fxMesa->haveHwAlpha;
   GrAlphaBlendFnc_t sfact, dfact, asfact, adfact;

   /*
    * 15/16 BPP alpha channel alpha blending modes
    *   0x0	AZERO		Zero
    *   0x4	AONE		One
    *
    * 32 BPP alpha channel alpha blending modes
    *   0x0	AZERO		Zero
    *   0x1	ASRC_ALPHA	Source alpha
    *   0x3	ADST_ALPHA	Destination alpha
    *   0x4	AONE		One
    *   0x5	AOMSRC_ALPHA	1 - Source alpha
    *   0x7	AOMDST_ALPHA	1 - Destination alpha
    *
    * If we don't have HW alpha buffer:
    *   DST_ALPHA == 1
    *   ONE_MINUS_DST_ALPHA == 0
    * Unsupported modes are:
    *   1 if used as src blending factor
    *   0 if used as dst blending factor
    */

   switch (sfactor) {
   case GL_ZERO:
      sfact = GR_BLEND_ZERO;
      break;
   case GL_ONE:
      sfact = GR_BLEND_ONE;
      break;
   case GL_DST_COLOR:
      sfact = GR_BLEND_DST_COLOR;
      break;
   case GL_ONE_MINUS_DST_COLOR:
      sfact = GR_BLEND_ONE_MINUS_DST_COLOR;
      break;
   case GL_SRC_ALPHA:
      sfact = GR_BLEND_SRC_ALPHA;
      break;
   case GL_ONE_MINUS_SRC_ALPHA:
      sfact = GR_BLEND_ONE_MINUS_SRC_ALPHA;
      break;
   case GL_DST_ALPHA:
      sfact = haveAlpha ? GR_BLEND_DST_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_ONE_MINUS_DST_ALPHA:
      sfact = haveAlpha ? GR_BLEND_ONE_MINUS_DST_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   case GL_SRC_ALPHA_SATURATE:
      sfact = GR_BLEND_ALPHA_SATURATE;
      break;
   case GL_SRC_COLOR:
      if (isNapalm) {
         sfact = GR_BLEND_SAME_COLOR_EXT;
         break;
      }
   case GL_ONE_MINUS_SRC_COLOR:
      if (isNapalm) {
         sfact = GR_BLEND_ONE_MINUS_SAME_COLOR_EXT;
         break;
      }
   default:
      sfact = GR_BLEND_ONE;
      break;
   }

   switch (asfactor) {
   case GL_ZERO:
      asfact = GR_BLEND_ZERO;
      break;
   case GL_ONE:
      asfact = GR_BLEND_ONE;
      break;
   case GL_SRC_COLOR:
   case GL_SRC_ALPHA:
      asfact = have32bpp ? GR_BLEND_SRC_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_ONE_MINUS_SRC_COLOR:
   case GL_ONE_MINUS_SRC_ALPHA:
      asfact = have32bpp ? GR_BLEND_ONE_MINUS_SRC_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_DST_COLOR:
   case GL_DST_ALPHA:
      asfact = (have32bpp && haveAlpha) ? GR_BLEND_DST_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_ONE_MINUS_DST_COLOR:
   case GL_ONE_MINUS_DST_ALPHA:
      asfact = (have32bpp && haveAlpha) ? GR_BLEND_ONE_MINUS_DST_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   case GL_SRC_ALPHA_SATURATE:
      asfact = GR_BLEND_ONE;
      break;
   default:
      asfact = GR_BLEND_ONE;
      break;
   }

   switch (dfactor) {
   case GL_ZERO:
      dfact = GR_BLEND_ZERO;
      break;
   case GL_ONE:
      dfact = GR_BLEND_ONE;
      break;
   case GL_SRC_COLOR:
      dfact = GR_BLEND_SRC_COLOR;
      break;
   case GL_ONE_MINUS_SRC_COLOR:
      dfact = GR_BLEND_ONE_MINUS_SRC_COLOR;
      break;
   case GL_SRC_ALPHA:
      dfact = GR_BLEND_SRC_ALPHA;
      break;
   case GL_ONE_MINUS_SRC_ALPHA:
      dfact = GR_BLEND_ONE_MINUS_SRC_ALPHA;
      break;
   case GL_DST_ALPHA:
      dfact = haveAlpha ? GR_BLEND_DST_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_ONE_MINUS_DST_ALPHA:
      dfact = haveAlpha ? GR_BLEND_ONE_MINUS_DST_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   case GL_DST_COLOR:
      if (isNapalm) {
         dfact = GR_BLEND_SAME_COLOR_EXT;
         break;
      }
   case GL_ONE_MINUS_DST_COLOR:
      if (isNapalm) {
         dfact = GR_BLEND_ONE_MINUS_SAME_COLOR_EXT;
         break;
      }
   default:
      dfact = GR_BLEND_ZERO;
      break;
   }

   switch (adfactor) {
   case GL_ZERO:
      adfact = GR_BLEND_ZERO;
      break;
   case GL_ONE:
      adfact = GR_BLEND_ONE;
      break;
   case GL_SRC_COLOR:
   case GL_SRC_ALPHA:
      adfact = have32bpp ? GR_BLEND_SRC_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   case GL_ONE_MINUS_SRC_COLOR:
   case GL_ONE_MINUS_SRC_ALPHA:
      adfact = have32bpp ? GR_BLEND_ONE_MINUS_SRC_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   case GL_DST_COLOR:
   case GL_DST_ALPHA:
      adfact = (have32bpp && haveAlpha) ? GR_BLEND_DST_ALPHA : GR_BLEND_ONE/*bad*/;
      break;
   case GL_ONE_MINUS_DST_COLOR:
   case GL_ONE_MINUS_DST_ALPHA:
      adfact = (have32bpp && haveAlpha) ? GR_BLEND_ONE_MINUS_DST_ALPHA : GR_BLEND_ZERO/*bad*/;
      break;
   default:
      adfact = GR_BLEND_ZERO;
      break;
   }

   if ((sfact != us->blendSrcFuncRGB) || (asfact != us->blendSrcFuncAlpha)) {
      us->blendSrcFuncRGB = sfact;
      us->blendSrcFuncAlpha = asfact;
      fxMesa->new_state |= FX_NEW_BLEND;
   }

   if ((dfact != us->blendDstFuncRGB) || (adfact != us->blendDstFuncAlpha)) {
      us->blendDstFuncRGB = dfact;
      us->blendDstFuncAlpha = adfact;
      fxMesa->new_state |= FX_NEW_BLEND;
   }
}

void
fxDDBlendEquationSeparate(GLcontext * ctx, GLenum modeRGB, GLenum modeA)
{
 fxMesaContext fxMesa = FX_CONTEXT(ctx);
 tfxUnitsState *us = &fxMesa->unitsState;
 GrAlphaBlendOp_t q;

 switch (modeRGB) {
        case GL_FUNC_ADD:
             q = GR_BLEND_OP_ADD;
             break;
        case GL_FUNC_SUBTRACT:
             q = GR_BLEND_OP_SUB;
             break;
        case GL_FUNC_REVERSE_SUBTRACT:
             q = GR_BLEND_OP_REVSUB;
             break;
        default:
             q = us->blendEqRGB;
 }
 if (q != us->blendEqRGB) {
    us->blendEqRGB = q;
    fxMesa->new_state |= FX_NEW_BLEND;
 }

 switch (modeA) {
        case GL_FUNC_ADD:
             q = GR_BLEND_OP_ADD;
             break;
        case GL_FUNC_SUBTRACT:
             q = GR_BLEND_OP_SUB;
             break;
        case GL_FUNC_REVERSE_SUBTRACT:
             q = GR_BLEND_OP_REVSUB;
             break;
        default:
             q = us->blendEqAlpha;
 }
 if (q != us->blendEqAlpha) {
    us->blendEqAlpha = q;
    fxMesa->new_state |= FX_NEW_BLEND;
 }
}

void
fxSetupBlend(GLcontext * ctx)
{
 fxMesaContext fxMesa = FX_CONTEXT(ctx);
 tfxUnitsState *us = &fxMesa->unitsState;

 if (fxMesa->HavePixExt) {
    if (us->blendEnabled) {
       fxMesa->Glide.grAlphaBlendFunctionExt(us->blendSrcFuncRGB, us->blendDstFuncRGB,
                                             us->blendEqRGB,
                                             us->blendSrcFuncAlpha, us->blendDstFuncAlpha,
                                             us->blendEqAlpha);
    } else {
       fxMesa->Glide.grAlphaBlendFunctionExt(GR_BLEND_ONE, GR_BLEND_ZERO,
                                             GR_BLEND_OP_ADD,
                                             GR_BLEND_ONE, GR_BLEND_ZERO,
                                             GR_BLEND_OP_ADD);
    }
 } else {
    if (us->blendEnabled) {
       grAlphaBlendFunction(us->blendSrcFuncRGB, us->blendDstFuncRGB,
                            us->blendSrcFuncAlpha, us->blendDstFuncAlpha);
    } else {
       grAlphaBlendFunction(GR_BLEND_ONE, GR_BLEND_ZERO,
                            GR_BLEND_ONE, GR_BLEND_ZERO);
    }
 }
}

/************************************************************************/
/************************** Alpha Test SetUp ****************************/
/************************************************************************/

void
fxDDAlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;

   if (
       (us->alphaTestFunc != func)
       ||
       (us->alphaTestRefValue != ref)
      ) {
      us->alphaTestFunc = func;
      us->alphaTestRefValue = ref;
      fxMesa->new_state |= FX_NEW_ALPHA;
   }
}

static void
fxSetupAlphaTest(GLcontext * ctx)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;

   if (us->alphaTestEnabled) {
      GrAlpha_t ref = (GLint) (us->alphaTestRefValue * 255.0);
      grAlphaTestFunction(us->alphaTestFunc - GL_NEVER + GR_CMP_NEVER);
      grAlphaTestReferenceValue(ref);
   }
   else
      grAlphaTestFunction(GR_CMP_ALWAYS);
}

/************************************************************************/
/************************** Depth Test SetUp ****************************/
/************************************************************************/

void
fxDDDepthFunc(GLcontext * ctx, GLenum func)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;

   if (us->depthTestFunc != func) {
      us->depthTestFunc = func;
      fxMesa->new_state |= FX_NEW_DEPTH;
   }
}

void
fxDDDepthMask(GLcontext * ctx, GLboolean flag)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;

   if (flag != us->depthMask) {
      us->depthMask = flag;
      fxMesa->new_state |= FX_NEW_DEPTH;
   }
}

void
fxSetupDepthTest(GLcontext * ctx)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   tfxUnitsState *us = &fxMesa->unitsState;

   if (us->depthTestEnabled) {
      grDepthBufferFunction(us->depthTestFunc - GL_NEVER + GR_CMP_NEVER);
      grDepthMask(us->depthMask);
   }
   else {
      grDepthBufferFunction(GR_CMP_ALWAYS);
      grDepthMask(FXFALSE);
   }
}

/************************************************************************/
/************************** Stencil SetUp *******************************/
/************************************************************************/