mga_texcombine.c

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

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