tdfx_texstate.c

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

               /*
                * The formula is: Arg0
                * We implement this by the formula:
                *   (Arg0 + 0(0))*(1-0) + 0
                */
                TEXENV_SETUP_ARG_A(A_A,
                                   texUnit->Combine.SourceA[0],
                                   texUnit->Combine.OperandA[0],
                                   incomingAlpha);
                TEXENV_SETUP_MODE_A(Amode_A,
                                    texUnit->Combine.OperandA[0]);
                B_A = GR_CMBX_ITALPHA;
                Bmode_A = GR_FUNC_MODE_ZERO;
                C_A = D_A = GR_CMBX_ZERO;
                Cinv_A = FXTRUE;
                Dinv_A = Ginv_A = FXFALSE;
                break;
            case GL_MODULATE:
               /*
                * The formula is: Arg0 * Arg1
                *
                * We implement this by the formula
                *   (Arg0 + 0(0)) * Arg1 + 0(0)
                */
                TEXENV_SETUP_ARG_A(A_A,
                                   texUnit->Combine.SourceA[0],
                                   texUnit->Combine.OperandA[0],
                                   incomingAlpha);
                TEXENV_SETUP_MODE_A(Amode_A,
                                    texUnit->Combine.OperandA[0]);
                B_A = GR_CMBX_ZERO;
                Bmode_A = GR_CMBX_ZERO;
                TEXENV_SETUP_ARG_A(C_A,
                                   texUnit->Combine.SourceA[1],
                                   texUnit->Combine.OperandA[1],
                                   incomingAlpha);
                Cinv_A = TEXENV_OPERAND_INVERTED
                               (texUnit->Combine.OperandA[1]);
                D_A = GR_CMBX_ZERO;
                Dinv_A = Ginv_A = FXFALSE;
                break;
            case GL_ADD:
               /*
                * The formula is Arg0 + Arg1
                */
                TEXENV_SETUP_ARG_A(A_A,
                                   texUnit->Combine.SourceA[0],
                                   texUnit->Combine.OperandA[0],
                                   incomingAlpha);
                TEXENV_SETUP_MODE_A(Amode_A,
                                    texUnit->Combine.OperandA[0]);
                TEXENV_SETUP_ARG_A(B_A,
                                   texUnit->Combine.SourceA[1],
                                   texUnit->Combine.OperandA[1],
                                   incomingAlpha);
                TEXENV_SETUP_MODE_A(Bmode_A,
                                    texUnit->Combine.OperandA[1]);
                C_A = D_A = GR_CMBX_ZERO;
                Cinv_A = FXTRUE;
                Dinv_A = Ginv_A = FXFALSE;
                break;
            case GL_ADD_SIGNED_EXT:
               /*
                * The formula is: Arg0 + Arg1 - 0.5.
                * We compute this by calculating:
                *      (Arg0 - 1/2) + Arg1         if op0 is SRC_{COLOR,ALPHA}
                *      Arg0 + (Arg1 - 1/2)         if op1 is SRC_{COLOR,ALPHA}
                * If both op0 and op1 are ONE_MINUS_SRC_{COLOR,ALPHA}
                * we cannot implement the formula properly.
                */
                TEXENV_SETUP_ARG_A(A_A,
                                   texUnit->Combine.SourceA[0],
                                   texUnit->Combine.OperandA[0],
                                   incomingAlpha);
                TEXENV_SETUP_ARG_A(B_A,
                                   texUnit->Combine.SourceA[1],
                                   texUnit->Combine.OperandA[1],
                                   incomingAlpha);
                if (!TEXENV_OPERAND_INVERTED(texUnit->Combine.OperandA[0])) {
                   /*
                    * A is not inverted.  So, choose it.
                    */
                    Amode_A = GR_FUNC_MODE_X_MINUS_HALF;
                    if (!TEXENV_OPERAND_INVERTED
                            (texUnit->Combine.OperandA[1])) {
                        Bmode_A = GR_FUNC_MODE_X;
                    } else {
                        Bmode_A = GR_FUNC_MODE_ONE_MINUS_X;
                    }
                } else {
                   /*
                    * A is inverted, so try to subtract 1/2
                    * from B.
                    */
                    Amode_A = GR_FUNC_MODE_ONE_MINUS_X;
                    if (!TEXENV_OPERAND_INVERTED
                            (texUnit->Combine.OperandA[1])) {
                        Bmode_A = GR_FUNC_MODE_X_MINUS_HALF;
                    } else {
                       /*
                        * Both are inverted.  This is the case
                        * we cannot handle properly.  We just
                        * choose to not add the - 1/2.
                        */
                        Bmode_A = GR_FUNC_MODE_ONE_MINUS_X;
                        return GL_FALSE;
                    }
                }
                C_A = D_A = GR_CMBX_ZERO;
                Cinv_A = FXTRUE;
                Dinv_A = Ginv_A = FXFALSE;
                break;
            case GL_INTERPOLATE_EXT:
               /*
                * The formula is: Arg0 * Arg2 + Arg1 * (1 - Arg2).
                * We compute this by the formula:
                *            (Arg0 - Arg1) * Arg2 + Arg1
                *               == Arg0 * Arg2 - Arg1 * Arg2 + Arg1
                *               == Arg0 * Arg2 + Arg1 * (1 - Arg2)
                * However, if both Arg1 is ONE_MINUS_X, the HW does
                * not support it properly.
                */
                TEXENV_SETUP_ARG_A(A_A,
                                   texUnit->Combine.SourceA[0],
                                   texUnit->Combine.OperandA[0],
                                   incomingAlpha);
                TEXENV_SETUP_MODE_A(Amode_A,
                                    texUnit->Combine.OperandA[0]);
                TEXENV_SETUP_ARG_A(B_A,
                                   texUnit->Combine.SourceA[1],
                                   texUnit->Combine.OperandA[1],
                                   incomingAlpha);
                if (!TEXENV_OPERAND_INVERTED(texUnit->Combine.OperandA[1])) {
                    Bmode_A = GR_FUNC_MODE_NEGATIVE_X;
                }
                else {
                   /*
                    * This case is wrong.
                    */
                    Bmode_A = GR_FUNC_MODE_NEGATIVE_X;
                    return GL_FALSE;
                }
               /*
                * The Source/Operand for the C value must
                * specify some kind of alpha value.
                */
                TEXENV_SETUP_ARG_A(C_A,
                                   texUnit->Combine.SourceA[2],
                                   texUnit->Combine.OperandA[2],
                                   incomingAlpha);
                Cinv_A = FXFALSE;
                D_A = GR_CMBX_B;
                Dinv_A = Ginv_A = FXFALSE;
                break;
            default:
               /*
                * This is here mostly to keep from getting
                * a compiler warning about these not being set.
                * However, this should set all the alpha values
                * to one.
                */
                A_A = B_A = C_A = D_A = GR_CMBX_ZERO;
                Amode_A = Bmode_A = GR_FUNC_MODE_X;
                Cinv_A = Dinv_A = FXFALSE;
                Ginv_A = FXTRUE;
                break;
            }
           /*
            * Save the parameters.
            */
            env->Color.SourceA = A_RGB;
            env->Color.ModeA = Amode_RGB;
            env->Color.SourceB = B_RGB;
            env->Color.ModeB = Bmode_RGB;
            env->Color.SourceC = C_RGB;
            env->Color.InvertC = Cinv_RGB;
            env->Color.SourceD = D_RGB;
            env->Color.InvertD = Dinv_RGB;
            env->Color.Shift = Shift_RGB;
            env->Color.Invert = Ginv_RGB;
            env->Alpha.SourceA = A_A;
            env->Alpha.ModeA = Amode_A;
            env->Alpha.SourceB = B_A;
            env->Alpha.ModeB = Bmode_A;
            env->Alpha.SourceC = C_A;
            env->Alpha.InvertC = Cinv_A;
            env->Alpha.SourceD = D_A;
            env->Alpha.InvertD = Dinv_A;
            env->Alpha.Shift = Shift_A;
            env->Alpha.Invert = Ginv_A;
            env->EnvColor = PACK_RGBA32(texUnit->EnvColor[0] * 255.0F,
                                        texUnit->EnvColor[1] * 255.0F,
                                        texUnit->EnvColor[2] * 255.0F,
                                        texUnit->EnvColor[3] * 255.0F);
        }
        break;

    default:
        _mesa_problem(ctx, "%s: Bad envMode", __FUNCTION__);
    }

    fxMesa->dirty |= TDFX_UPLOAD_TEXTURE_ENV;

    fxMesa->ColorCombineExt.SourceA = GR_CMBX_TEXTURE_RGB;
    fxMesa->ColorCombineExt.ModeA = GR_FUNC_MODE_X,
    fxMesa->ColorCombineExt.SourceB = GR_CMBX_ZERO;
    fxMesa->ColorCombineExt.ModeB = GR_FUNC_MODE_X;
    fxMesa->ColorCombineExt.SourceC = GR_CMBX_ZERO;
    fxMesa->ColorCombineExt.InvertC = FXTRUE;
    fxMesa->ColorCombineExt.SourceD = GR_CMBX_ZERO;
    fxMesa->ColorCombineExt.InvertD = FXFALSE;
    fxMesa->ColorCombineExt.Shift = 0;
    fxMesa->ColorCombineExt.Invert = FXFALSE;
    fxMesa->dirty |= TDFX_UPLOAD_COLOR_COMBINE;
    fxMesa->AlphaCombineExt.SourceA = GR_CMBX_TEXTURE_ALPHA;
    fxMesa->AlphaCombineExt.ModeA = GR_FUNC_MODE_X;
    fxMesa->AlphaCombineExt.SourceB = GR_CMBX_ZERO;
    fxMesa->AlphaCombineExt.ModeB = GR_FUNC_MODE_X;
    fxMesa->AlphaCombineExt.SourceC = GR_CMBX_ZERO;
    fxMesa->AlphaCombineExt.InvertC = FXTRUE;
    fxMesa->AlphaCombineExt.SourceD = GR_CMBX_ZERO;
    fxMesa->AlphaCombineExt.InvertD = FXFALSE;
    fxMesa->AlphaCombineExt.Shift = 0;
    fxMesa->AlphaCombineExt.Invert = FXFALSE;
    fxMesa->dirty |= TDFX_UPLOAD_ALPHA_COMBINE;
    return GL_TRUE; /* success */
}



/*
 * Setup the Voodoo3 texture environment for a single texture unit.
 * Return GL_TRUE for success, GL_FALSE for failure.
 * If failure, we'll use software rendering.
 */
static GLboolean
SetupSingleTexEnvVoodoo3(GLcontext *ctx, int unit,
                         GLenum envMode, GLenum baseFormat)
{
   tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
   GrCombineLocal_t localc, locala;
   struct tdfx_combine alphaComb, colorComb;

   if (1 /*iteratedRGBA*/)
      localc = locala = GR_COMBINE_LOCAL_ITERATED;
   else
      localc = locala = GR_COMBINE_LOCAL_CONSTANT;

   switch (envMode) {
   case GL_DECAL:
      alphaComb.Function = GR_COMBINE_FUNCTION_LOCAL;
      alphaComb.Factor = GR_COMBINE_FACTOR_NONE;
      alphaComb.Local = locala;
      alphaComb.Other = GR_COMBINE_OTHER_NONE;
      alphaComb.Invert = FXFALSE;
      colorComb.Function = GR_COMBINE_FUNCTION_BLEND;
      colorComb.Factor = GR_COMBINE_FACTOR_TEXTURE_ALPHA;
      colorComb.Local = localc;
      colorComb.Other = GR_COMBINE_OTHER_TEXTURE;
      colorComb.Invert = FXFALSE;
      break;
   case GL_MODULATE:
      alphaComb.Function = GR_COMBINE_FUNCTION_SCALE_OTHER;
      alphaComb.Factor = GR_COMBINE_FACTOR_LOCAL;
      alphaComb.Local = locala;
      alphaComb.Other = GR_COMBINE_OTHER_TEXTURE;
      alphaComb.Invert = FXFALSE;
      if (baseFormat == GL_ALPHA) {
         colorComb.Function = GR_COMBINE_FUNCTION_LOCAL;
         colorComb.Factor = GR_COMBINE_FACTOR_NONE;
         colorComb.Local = localc;
         colorComb.Other = GR_COMBINE_OTHER_NONE;
         colorComb.Invert = FXFALSE;
      }
      else {
         colorComb.Function = GR_COMBINE_FUNCTION_SCALE_OTHER;
         colorComb.Factor = GR_COMBINE_FACTOR_LOCAL;
         colorComb.Local = localc;
         colorComb.Other = GR_COMBINE_OTHER_TEXTURE;
         colorComb.Invert = FXFALSE;
      }
      break;

   case GL_BLEND:
      /*
       * XXX we can't do real GL_BLEND mode.  These settings assume that
       * the TexEnv color is black and incoming fragment color is white.
       */
      if (baseFormat == GL_LUMINANCE || baseFormat == GL_RGB) {
         /* Av = Af */
         alphaComb.Function = GR_COMBINE_FUNCTION_LOCAL;
         alphaComb.Factor = GR_COMBINE_FACTOR_NONE;
         alphaComb.Local = locala;
         alphaComb.Other = GR_COMBINE_OTHER_NONE;
         alphaComb.Invert = FXFALSE;
      }
      else if (baseFormat == GL_INTENSITY) {
         /* Av = Af * (1 - It) + Ac * It */
         alphaComb.Function = GR_COMBINE_FUNCTION_BLEND;
         alphaComb.Factor = GR_COMBINE_FACTOR_TEXTURE_ALPHA;
         alphaComb.Local = locala;
         alphaComb.Other = GR_COMBINE_OTHER_CONSTANT;
         alphaComb.Invert = FXFALSE;