path: root/nx-X11/extras/Mesa/src/mesa/drivers/dri/mga/mga_texcombine.c

/*
 * Copyright (c) 2003 Ville Syrjala
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *    Ville Syrjala <syrjala@sci.fi>
 */

#include "glheader.h"

#include "mgacontext.h"
#include "mgatex.h"
#include "mgaregs.h"

/*
 * GL_ARB_texture_env_combine
 * GL_EXT_texture_env_combine
 * GL_ARB_texture_env_crossbar
 * GL_ATI_texture_env_combine3
 */

#define ARG_DISABLE 0xffffffff
#define MGA_ARG1  0
#define MGA_ARG2  1
#define MGA_ALPHA 2

GLboolean mgaUpdateTextureEnvCombine( GLcontext *ctx, int unit )
{
   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
   const int source = mmesa->tmu_source[unit];
   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
   GLuint *reg = ((GLuint *)&mmesa->setup.tdualstage0 + unit);
   GLuint numColorArgs = 0, numAlphaArgs = 0;
   GLuint arg1[3], arg2[3], alpha[3];
   int args[3];
   int i;

   switch (texUnit->Combine.ModeRGB) {
   case GL_REPLACE:
      numColorArgs = 1;
      break;
   case GL_MODULATE:
   case GL_ADD:
   case GL_ADD_SIGNED:
   case GL_SUBTRACT:
      numColorArgs = 2;
      break;
   case GL_INTERPOLATE:
   case GL_MODULATE_ADD_ATI:
   case GL_MODULATE_SIGNED_ADD_ATI:
   case GL_MODULATE_SUBTRACT_ATI:
      numColorArgs = 3;
      break;
   default:
      return GL_FALSE;
   }

   switch (texUnit->Combine.ModeA) {
   case GL_REPLACE:
      numAlphaArgs = 1;
      break;
   case GL_MODULATE:
   case GL_ADD:
   case GL_ADD_SIGNED:
   case GL_SUBTRACT:
      numAlphaArgs = 2;
      break;
   default:
      return GL_FALSE;
   }

   /* Start fresh :) */
   *reg = 0;

   /* COLOR */
   for (i = 0; i < 3; i++) {
      arg1[i] = 0;
      arg2[i] = 0;
      alpha[i] = 0;
   }

   for (i = 0;i < numColorArgs; i++) {
      switch (texUnit->Combine.SourceRGB[i]) {
      case GL_TEXTURE:
         arg1[i] |= 0;
         arg2[i] |= ARG_DISABLE;
         alpha[i] |= TD0_color_alpha_currtex;
         break;
      case GL_TEXTURE0:
         if (source == 0) {
            arg1[i] |= 0;
            arg2[i] |= ARG_DISABLE;
            alpha[i] |= TD0_color_alpha_currtex;
         } else {
            if (ctx->Texture._EnabledUnits != 0x03) {
               /* disable texturing */
               mmesa->setup.dwgctl &= DC_opcod_MASK;
               mmesa->setup.dwgctl |= DC_opcod_trap;
               mmesa->hw.alpha_sel = AC_alphasel_diffused;
               /* return GL_TRUE since we don't need a fallback */
               return GL_TRUE;
            }
            arg1[i] |= ARG_DISABLE;
            arg2[i] |= ARG_DISABLE;
            alpha[i] |= TD0_color_alpha_prevtex;
         }
         break;
      case GL_TEXTURE1:
         if (source == 0) {
            if (ctx->Texture._EnabledUnits != 0x03) {
               /* disable texturing */
               mmesa->setup.dwgctl &= DC_opcod_MASK;
               mmesa->setup.dwgctl |= DC_opcod_trap;
               mmesa->hw.alpha_sel = AC_alphasel_diffused;
               /* return GL_TRUE since we don't need a fallback */
               return GL_TRUE;
            }
            arg1[i] |= ARG_DISABLE;
            /* G400 specs (TDUALSTAGE0) */
            arg2[i] |= TD0_color_arg2_prevstage;
            alpha[i] |= TD0_color_alpha_prevstage;
         } else {
            arg1[i] |= 0;
            arg2[i] |= ARG_DISABLE;
            alpha[i] |= TD0_color_alpha_currtex;
         }
         break;
      case GL_CONSTANT:
         if (mmesa->fcol_used &&
             mmesa->envcolor[source] != mmesa->envcolor[!source])
            return GL_FALSE;

         arg1[i] |= ARG_DISABLE;
         arg2[i] |= TD0_color_arg2_fcol;
         alpha[i] |= TD0_color_alpha_fcol;

         mmesa->setup.fcol = mmesa->envcolor[source];
         mmesa->fcol_used = GL_TRUE;
         break;
      case GL_PRIMARY_COLOR:
         arg1[i] |= ARG_DISABLE;
         /* G400 specs (TDUALSTAGE1) */
         if (unit == 0 || (mmesa->setup.tdualstage0 &
                           ((TD0_color_sel_mul & TD0_color_sel_add) |
                            (TD0_alpha_sel_mul & TD0_alpha_sel_add)))) {
            arg2[i] |= TD0_color_arg2_diffuse;
            alpha[i] |= TD0_color_alpha_diffuse;
         } else {
            arg2[i] |= ARG_DISABLE;
            alpha[i] |= ARG_DISABLE;
         }
         break;
      case GL_PREVIOUS:
         arg1[i] |= ARG_DISABLE;
         if (unit == 0) {
            arg2[i] |= TD0_color_arg2_diffuse;
            alpha[i] |= TD0_color_alpha_diffuse;
         } else {
            arg2[i] |= TD0_color_arg2_prevstage;
            alpha[i] |= TD0_color_alpha_prevstage;
         }
         break;
      default:
         return GL_FALSE;
      }

      switch (texUnit->Combine.OperandRGB[i]) {
      case GL_SRC_COLOR:
         arg1[i] |= 0;
         arg2[i] |= 0;
         if (texUnit->Combine.SourceRGB[i] == GL_CONSTANT &&
             RGBA_EQUAL( mmesa->envcolor[source] )) {
            alpha[i] |= 0;
         } else {
            alpha[i] |= ARG_DISABLE;
         }
         break;
      case GL_ONE_MINUS_SRC_COLOR:
         arg1[i] |= TD0_color_arg1_inv_enable;
         arg2[i] |= TD0_color_arg2_inv_enable;
         if (texUnit->Combine.SourceRGB[i] == GL_CONSTANT &&
             RGBA_EQUAL( mmesa->envcolor[source] )) {
            alpha[i] |= (TD0_color_alpha1inv_enable |
                         TD0_color_alpha2inv_enable);
         } else {
            alpha[i] |= ARG_DISABLE;
         }
         break;
      case GL_SRC_ALPHA:
         arg1[i] |= TD0_color_arg1_replicatealpha_enable;
         arg2[i] |= TD0_color_arg2_replicatealpha_enable;
         alpha[i] |= 0;
         break;
      case GL_ONE_MINUS_SRC_ALPHA:
         arg1[i] |= (TD0_color_arg1_replicatealpha_enable |
                     TD0_color_arg1_inv_enable);
         arg2[i] |= (TD0_color_arg2_replicatealpha_enable |
                     TD0_color_arg2_inv_enable);
         alpha[i] |= (TD0_color_alpha1inv_enable |
                      TD0_color_alpha2inv_enable);
         break;
      }
   }

   switch (texUnit->Combine.ModeRGB) {
   case GL_MODULATE_ADD_ATI:
   case GL_MODULATE_SIGNED_ADD_ATI:
      /* Special handling for ATI_texture_env_combine3.
       * If Arg1 == Arg0 or Arg1 == Arg2 we can use arg1 or arg2 as input for
       * both multiplier and adder.
       */
      /* Arg1 == arg1 */
      if (arg1[1] == arg1[0]) {
         if ((arg1[1] | arg2[2]) != ARG_DISABLE) {
            *reg |= arg1[1] | arg2[2];
            args[0] = MGA_ARG1; args[1] = MGA_ARG1; args[2] = MGA_ARG2;
            break;
         } else
         if ((arg1[1] | alpha[2]) != ARG_DISABLE) {
            *reg |= arg1[1] | alpha[2];
            args[0] = MGA_ARG1; args[1] = MGA_ARG1; args[2] = MGA_ALPHA;
            break;
         }
      }
      if (arg1[1] == arg1[2]) {
         if ((arg1[1] | arg2[0]) != ARG_DISABLE) {
            *reg |= arg1[1] | arg2[0];
            args[0] = MGA_ARG2; args[1] = MGA_ARG1; args[2] = MGA_ARG1;
            break;
         } else
         if ((arg1[1] | alpha[0]) != ARG_DISABLE) {
            *reg |= arg1[1] | alpha[0];
            args[0] = MGA_ALPHA; args[1] = MGA_ARG1; args[2] = MGA_ARG1;
            break;
         }
      }
      /* fallthrough */
   case GL_MODULATE_SUBTRACT_ATI:
      /* Arg1 == arg2 */
      if (arg2[1] == arg2[0]) {
         if ((arg2[1] | arg1[2]) != ARG_DISABLE) {
            *reg |= arg2[1] | arg1[2];
            args[0] = MGA_ARG2; args[1] = MGA_ARG2; args[2] = MGA_ARG1;
            break;
         } else
         if ((arg2[1] | alpha[2]) != ARG_DISABLE) {
            *reg |= arg2[1] | alpha[2];
            args[0] = MGA_ARG2; args[1] = MGA_ARG2; args[2] = MGA_ALPHA;
            break;
         }
      }
      if (arg2[1] == arg2[2]) {
         if ((arg2[1] | arg1[0]) != ARG_DISABLE) {
            *reg |= arg2[1] | arg1[0];
            args[0] = MGA_ARG1; args[1] = MGA_ARG2; args[2] = MGA_ARG2;
            break;
         } else
         if ((arg2[1] | alpha[0]) != ARG_DISABLE) {
            *reg |= arg2[1] | alpha[0];
            args[0] = MGA_ALPHA; args[1] = MGA_ARG2; args[2] = MGA_ARG2;
            break;
         }
      }
      /* fallthrough */
   default:
      /* Find working combo of arg1, arg2 and alpha.
       *
       * Keep the Arg0 != alpha cases first since there's
       * no way to get alpha out by itself (GL_REPLACE).
       *
       * Keep the Arg2 == alpha cases first because only alpha has the
       * capabilities to function as Arg2 (GL_INTERPOLATE). Also good for 
       * GL_ADD, GL_ADD_SIGNED, GL_SUBTRACT since we can't get alpha to the
       * adder.
       *
       * Keep the Arg1 == alpha cases last for GL_MODULATE_ADD_ATI,
       * GL_MODULATE_SIGNED_ADD_ATI. Again because we can't get alpha to the
       * adder.
       *
       * GL_MODULATE_SUBTRACT_ATI needs special treatment since it requires
       * that Arg1 == arg2. This requirement clashes with those of other modes.
       */
      if ((arg1[0] | arg2[1] | alpha[2]) != ARG_DISABLE) {
         *reg |= arg1[0] | arg2[1] | alpha[2];
         args[0] = MGA_ARG1; args[1] = MGA_ARG2; args[2] = MGA_ALPHA;
      } else
      if ((arg1[1] | arg2[0] | alpha[2]) != ARG_DISABLE &&
          texUnit->Combine.ModeRGB != GL_MODULATE_SUBTRACT_ATI) {
         *reg |= arg1[1] | arg2[0] | alpha[2];
         args[0] = MGA_ARG2; args[1] = MGA_ARG1; args[2] = MGA_ALPHA;
      } else
      if ((arg1[1] | arg2[2] | alpha[0]) != ARG_DISABLE &&
          texUnit->Combine.ModeRGB != GL_MODULATE_SUBTRACT_ATI) {
         *reg |= arg1[1] | arg2[2] | alpha[0];
         args[0] = MGA_ALPHA; args[1] = MGA_ARG1; args[2] = MGA_ARG2;
      } else
      if ((arg1[2] | arg2[1] | alpha[0]) != ARG_DISABLE) {
         *reg |= arg1[2] | arg2[1] | alpha[0];
         args[0] = MGA_ALPHA; args[1] = MGA_ARG2; args[2] = MGA_ARG1;
      } else
      if ((arg1[0] | arg2[2] | alpha[1]) != ARG_DISABLE) {
         *reg |= arg1[0] | arg2[2] | alpha[1];
         args[0] = MGA_ARG1; args[1] = MGA_ALPHA; args[2] = MGA_ARG2;
      } else
      if ((arg1[2] | arg2[0] | alpha[1]) != ARG_DISABLE) {
         *reg |= arg1[2] | arg2[0] | alpha[1];
         args[0] = MGA_ARG2; args[1] = MGA_ALPHA; args[2] = MGA_ARG1;
      } else {
         /* nothing suitable */
         return GL_FALSE;
      }
   }

   switch (texUnit->Combine.ModeRGB) {
   case GL_REPLACE:
      if (texUnit->Combine.ScaleShiftRGB) {
         return GL_FALSE;
      }

      if (args[0] == MGA_ARG1) {
         *reg |= TD0_color_sel_arg1;
      } else if (args[0] == MGA_ARG2) {
         *reg |= TD0_color_sel_arg2;
      } else if (args[0] == MGA_ALPHA) {
         /* Can't get alpha out by itself */
         return GL_FALSE;
      }
      break;
   case GL_MODULATE:
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_modbright_2x;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         *reg |= TD0_color_modbright_4x;
      }

      *reg |= TD0_color_sel_mul;

      if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA) {
         if (args[0] == MGA_ARG1 || args[1] == MGA_ARG1) {
            *reg |= TD0_color_arg2mul_alpha2;
         } else if (args[0] == MGA_ARG2 || args[1] == MGA_ARG2) {
            *reg |= TD0_color_arg1mul_alpha1;
         }
      }
      break;
   case GL_ADD_SIGNED:
      *reg |= TD0_color_addbias_enable;
      /* fallthrough */
   case GL_ADD:
      if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA) {
         /* Can't get alpha to the adder */
         return GL_FALSE;
      }
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_color_add_add |
               TD0_color_sel_add);
      break;
   case GL_INTERPOLATE:
      if (args[2] != MGA_ALPHA) {
         /* Only alpha can function as Arg2 */
         return GL_FALSE;
      }
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_color_arg1mul_alpha1 |
               TD0_color_blend_enable |
               TD0_color_arg1add_mulout |
               TD0_color_arg2add_mulout |
               TD0_color_add_add |
               TD0_color_sel_add);

      /* Have to do this with xor since GL_ONE_MINUS_SRC_ALPHA may have
       * already touched this bit.
       */
      *reg ^= TD0_color_alpha1inv_enable;

      if (args[0] == MGA_ARG2) {
         /* Swap arguments */
         *reg ^= (TD0_color_arg1mul_alpha1 |
                  TD0_color_arg2mul_alpha2 |
                  TD0_color_alpha1inv_enable |
                  TD0_color_alpha2inv_enable);
      }

      if (ctx->Texture._EnabledUnits != 0x03) {
         /* Linear blending mode needs dualtex enabled */
         *(reg+1) = (TD0_color_arg2_prevstage |
                     TD0_color_sel_arg2 |
                     TD0_alpha_arg2_prevstage |
                     TD0_alpha_sel_arg2);
         mmesa->force_dualtex = GL_TRUE;
      }
      break;
   case GL_SUBTRACT:
      if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA) {
         /* Can't get alpha to the adder */
         return GL_FALSE;
      }
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_color_add_sub |
               TD0_color_sel_add);

      if (args[0] == MGA_ARG2) {
         /* Swap arguments */
         *reg ^= (TD0_color_arg1_inv_enable |
                  TD0_color_arg2_inv_enable);
      }
      break;
   case GL_MODULATE_SIGNED_ADD_ATI:
      *reg |= TD0_color_addbias_enable;
      /* fallthrough */
   case GL_MODULATE_ADD_ATI:
      if (args[1] == MGA_ALPHA) {
         /* Can't get alpha to the adder */
         return GL_FALSE;
      }
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_color_add_add |
               TD0_color_sel_add);

      if (args[1] == args[0] || args[1] == args[2]) {
         *reg |= TD0_color_arg1add_mulout;
         if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA)
            *reg |= TD0_color_arg1mul_alpha1;

         if (args[1] == MGA_ARG1) {
            /* Swap adder arguments */
            *reg ^= (TD0_color_arg1add_mulout |
                     TD0_color_arg2add_mulout);
            if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA) {
               /* Swap multiplier arguments */
               *reg ^= (TD0_color_arg1mul_alpha1 |
                        TD0_color_arg2mul_alpha2);
            }
         }
      } else {
         *reg |= (TD0_color_arg2mul_alpha2 |
                  TD0_color_arg1add_mulout);

         if (args[1] == MGA_ARG1) {
            /* Swap arguments */
            *reg ^= (TD0_color_arg1mul_alpha1 |
                     TD0_color_arg2mul_alpha2 |
                     TD0_color_arg1add_mulout |
                     TD0_color_arg2add_mulout);
         }
      }
      break;
   case GL_MODULATE_SUBTRACT_ATI:
      if (args[1] != MGA_ARG2) {
         /* Can't swap arguments */
         return GL_FALSE;
      }
      if (texUnit->Combine.ScaleShiftRGB == 1) {
         *reg |= TD0_color_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftRGB == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_color_add_sub |
               TD0_color_sel_add);

      if (args[1] == args[0] || args[1] == args[2]) {
         *reg |= TD0_color_arg1add_mulout;
         if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA)
            *reg |= TD0_color_arg1mul_alpha1;
      } else {
         *reg |= (TD0_color_arg2mul_alpha2 |
                  TD0_color_arg1add_mulout);
      }
      break;
   }


   /* ALPHA */
   for (i = 0; i < 2; i++) {
      arg1[i] = 0;
      arg2[i] = 0;
   }

   for (i = 0; i < numAlphaArgs; i++) {
      switch (texUnit->Combine.SourceA[i]) {
      case GL_TEXTURE:
         arg1[i] |= 0;
         arg2[i] |= ARG_DISABLE;
         break;
      case GL_TEXTURE0:
         if (source == 0) {
            arg1[i] |= 0;
            arg2[i] |= ARG_DISABLE;
         } else {
            if (ctx->Texture._EnabledUnits != 0x03) {
               /* disable texturing */
               mmesa->setup.dwgctl &= DC_opcod_MASK;
               mmesa->setup.dwgctl |= DC_opcod_trap;
               mmesa->hw.alpha_sel = AC_alphasel_diffused;
               /* return GL_TRUE since we don't need a fallback */
               return GL_TRUE;
            }
            arg1[i] |= ARG_DISABLE;
            arg2[i] |= TD0_alpha_arg2_prevtex;
         }
         break;
      case GL_TEXTURE1:
         if (source == 0) {
            if (ctx->Texture._EnabledUnits != 0x03) {
               /* disable texturing */
               mmesa->setup.dwgctl &= DC_opcod_MASK;
               mmesa->setup.dwgctl |= DC_opcod_trap;
               mmesa->hw.alpha_sel = AC_alphasel_diffused;
               /* return GL_TRUE since we don't need a fallback */
               return GL_TRUE;
            }
            arg1[i] |= ARG_DISABLE;
            /* G400 specs (TDUALSTAGE0) */
            arg2[i] |= TD0_alpha_arg2_prevstage;
         } else {
            arg1[i] |= 0;
            arg2[i] |= ARG_DISABLE;
         }
         break;
      case GL_CONSTANT:
         if (mmesa->fcol_used &&
             mmesa->envcolor[source] != mmesa->envcolor[!source])
            return GL_FALSE;

         arg1[i] |= ARG_DISABLE;
         arg2[i] |= TD0_alpha_arg2_fcol;

         mmesa->setup.fcol = mmesa->envcolor[source];
         mmesa->fcol_used = GL_TRUE;
         break;
      case GL_PRIMARY_COLOR:
         arg1[i] |= ARG_DISABLE;
         /* G400 specs (TDUALSTAGE1) */
         if (unit == 0 || (mmesa->setup.tdualstage0 &
                           ((TD0_color_sel_mul & TD0_color_sel_add) |
                            (TD0_alpha_sel_mul & TD0_alpha_sel_add)))) {
            arg2[i] |= TD0_alpha_arg2_diffuse;
         } else {
            arg2[i] |= ARG_DISABLE;
         }
         break;
      case GL_PREVIOUS:
         arg1[i] |= ARG_DISABLE;
         if (unit == 0) {
            arg2[i] |= TD0_alpha_arg2_diffuse;
         } else {
            arg2[i] |= TD0_alpha_arg2_prevstage;
         }
         break;
      default:
         return GL_FALSE;
      }

      switch (texUnit->Combine.OperandA[i]) {
      case GL_SRC_ALPHA:
         arg1[i] |= 0;
         arg2[i] |= 0;
         break;
      case GL_ONE_MINUS_SRC_ALPHA:
         arg1[i] |= TD0_alpha_arg1_inv_enable;
         arg2[i] |= TD0_alpha_arg2_inv_enable;
         break;
      }
   }

   /* Find a working combo of arg1 and arg2 */
   if ((arg1[0] | arg2[1]) != ARG_DISABLE) {
      *reg |= arg1[0] | arg2[1];
      args[0] = MGA_ARG1; args[1] = MGA_ARG2;
   } else
   if ((arg1[1] | arg2[0]) != ARG_DISABLE) {
      *reg |= arg1[1] | arg2[0];
      args[0] = MGA_ARG2; args[1] = MGA_ARG1;
   } else {
      /* nothing suitable */
      return GL_FALSE;
   }

   switch (texUnit->Combine.ModeA) {
   case GL_REPLACE:
      if (texUnit->Combine.ScaleShiftA) {
         return GL_FALSE;
      }

      if (args[0] == MGA_ARG1) {
         *reg |= TD0_alpha_sel_arg1;
      } else if (args[0] == MGA_ARG2) {
         *reg |= TD0_alpha_sel_arg2;
      }
      break;
   case GL_MODULATE:
      if (texUnit->Combine.ScaleShiftA == 1) {
         *reg |= TD0_alpha_modbright_2x;
      } else if (texUnit->Combine.ScaleShiftA == 2) {
         *reg |= TD0_alpha_modbright_4x;
      }

      *reg |= TD0_alpha_sel_mul;
      break;
   case GL_ADD_SIGNED:
      *reg |= TD0_alpha_addbias_enable;
      /* fallthrough */
   case GL_ADD:
      if (texUnit->Combine.ScaleShiftA == 1) {
         *reg |= TD0_alpha_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftA == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_alpha_add_enable |
               TD0_alpha_sel_add);
      break;
   case GL_SUBTRACT:
      if (texUnit->Combine.ScaleShiftA == 1) {
         *reg |= TD0_alpha_add2x_enable;
      } else if (texUnit->Combine.ScaleShiftA == 2) {
         return GL_FALSE;
      }

      *reg |= (TD0_alpha_add_disable |
               TD0_alpha_sel_add);

      if (args[0] == MGA_ARG2) {
         /* Swap arguments */
         *reg ^= (TD0_alpha_arg1_inv_enable |
                  TD0_alpha_arg2_inv_enable);
      }
      break;
   }

   return GL_TRUE;
}