r200_texstate.c

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

/* ================================================================
 * Texture combine functions
 */

/* GL_ARB_texture_env_combine support
 */

/* The color tables have combine functions for GL_SRC_COLOR,
 * GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA and GL_ONE_MINUS_SRC_ALPHA.
 */
static GLuint r200_register_color[][R200_MAX_TEXTURE_UNITS] =
{
   {
      R200_TXC_ARG_A_R0_COLOR,
      R200_TXC_ARG_A_R1_COLOR,
      R200_TXC_ARG_A_R2_COLOR,
      R200_TXC_ARG_A_R3_COLOR,
      R200_TXC_ARG_A_R4_COLOR,
      R200_TXC_ARG_A_R5_COLOR
   },
   {
      R200_TXC_ARG_A_R0_COLOR | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R1_COLOR | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R2_COLOR | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R3_COLOR | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R4_COLOR | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R5_COLOR | R200_TXC_COMP_ARG_A
   },
   {
      R200_TXC_ARG_A_R0_ALPHA,
      R200_TXC_ARG_A_R1_ALPHA,
      R200_TXC_ARG_A_R2_ALPHA,
      R200_TXC_ARG_A_R3_ALPHA,
      R200_TXC_ARG_A_R4_ALPHA,
      R200_TXC_ARG_A_R5_ALPHA
   },
   {
      R200_TXC_ARG_A_R0_ALPHA | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R1_ALPHA | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R2_ALPHA | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R3_ALPHA | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R4_ALPHA | R200_TXC_COMP_ARG_A,
      R200_TXC_ARG_A_R5_ALPHA | R200_TXC_COMP_ARG_A
   },
};

static GLuint r200_tfactor_color[] =
{
   R200_TXC_ARG_A_TFACTOR_COLOR,
   R200_TXC_ARG_A_TFACTOR_COLOR | R200_TXC_COMP_ARG_A,
   R200_TXC_ARG_A_TFACTOR_ALPHA,
   R200_TXC_ARG_A_TFACTOR_ALPHA | R200_TXC_COMP_ARG_A
};

static GLuint r200_tfactor1_color[] =
{
   R200_TXC_ARG_A_TFACTOR1_COLOR,
   R200_TXC_ARG_A_TFACTOR1_COLOR | R200_TXC_COMP_ARG_A,
   R200_TXC_ARG_A_TFACTOR1_ALPHA,
   R200_TXC_ARG_A_TFACTOR1_ALPHA | R200_TXC_COMP_ARG_A
};

static GLuint r200_primary_color[] =
{
   R200_TXC_ARG_A_DIFFUSE_COLOR,
   R200_TXC_ARG_A_DIFFUSE_COLOR | R200_TXC_COMP_ARG_A,
   R200_TXC_ARG_A_DIFFUSE_ALPHA,
   R200_TXC_ARG_A_DIFFUSE_ALPHA | R200_TXC_COMP_ARG_A
};

/* GL_ZERO table - indices 0-3
 * GL_ONE  table - indices 1-4
 */
static GLuint r200_zero_color[] =
{
   R200_TXC_ARG_A_ZERO,
   R200_TXC_ARG_A_ZERO | R200_TXC_COMP_ARG_A,
   R200_TXC_ARG_A_ZERO,
   R200_TXC_ARG_A_ZERO | R200_TXC_COMP_ARG_A,
   R200_TXC_ARG_A_ZERO
};

/* The alpha tables only have GL_SRC_ALPHA and GL_ONE_MINUS_SRC_ALPHA.
 */
static GLuint r200_register_alpha[][R200_MAX_TEXTURE_UNITS] =
{
   {
      R200_TXA_ARG_A_R0_ALPHA,
      R200_TXA_ARG_A_R1_ALPHA,
      R200_TXA_ARG_A_R2_ALPHA,
      R200_TXA_ARG_A_R3_ALPHA,
      R200_TXA_ARG_A_R4_ALPHA,
      R200_TXA_ARG_A_R5_ALPHA
   },
   {
      R200_TXA_ARG_A_R0_ALPHA | R200_TXA_COMP_ARG_A,
      R200_TXA_ARG_A_R1_ALPHA | R200_TXA_COMP_ARG_A,
      R200_TXA_ARG_A_R2_ALPHA | R200_TXA_COMP_ARG_A,
      R200_TXA_ARG_A_R3_ALPHA | R200_TXA_COMP_ARG_A,
      R200_TXA_ARG_A_R4_ALPHA | R200_TXA_COMP_ARG_A,
      R200_TXA_ARG_A_R5_ALPHA | R200_TXA_COMP_ARG_A
   },
};

static GLuint r200_tfactor_alpha[] =
{
   R200_TXA_ARG_A_TFACTOR_ALPHA,
   R200_TXA_ARG_A_TFACTOR_ALPHA | R200_TXA_COMP_ARG_A
};

static GLuint r200_tfactor1_alpha[] =
{
   R200_TXA_ARG_A_TFACTOR1_ALPHA,
   R200_TXA_ARG_A_TFACTOR1_ALPHA | R200_TXA_COMP_ARG_A
};

static GLuint r200_primary_alpha[] =
{
   R200_TXA_ARG_A_DIFFUSE_ALPHA,
   R200_TXA_ARG_A_DIFFUSE_ALPHA | R200_TXA_COMP_ARG_A
};

/* GL_ZERO table - indices 0-1
 * GL_ONE  table - indices 1-2
 */
static GLuint r200_zero_alpha[] =
{
   R200_TXA_ARG_A_ZERO,
   R200_TXA_ARG_A_ZERO | R200_TXA_COMP_ARG_A,
   R200_TXA_ARG_A_ZERO,
};


/* Extract the arg from slot A, shift it into the correct argument slot
 * and set the corresponding complement bit.
 */
#define R200_COLOR_ARG( n, arg )			\
do {							\
   color_combine |=					\
      ((color_arg[n] & R200_TXC_ARG_A_MASK)		\
       << R200_TXC_ARG_##arg##_SHIFT);			\
   color_combine |=					\
      ((color_arg[n] >> R200_TXC_COMP_ARG_A_SHIFT)	\
       << R200_TXC_COMP_ARG_##arg##_SHIFT);		\
} while (0)

#define R200_ALPHA_ARG( n, arg )			\
do {							\
   alpha_combine |=					\
      ((alpha_arg[n] & R200_TXA_ARG_A_MASK)		\
       << R200_TXA_ARG_##arg##_SHIFT);			\
   alpha_combine |=					\
      ((alpha_arg[n] >> R200_TXA_COMP_ARG_A_SHIFT)	\
       << R200_TXA_COMP_ARG_##arg##_SHIFT);		\
} while (0)


/* ================================================================
 * Texture unit state management
 */

static GLboolean r200UpdateTextureEnv( GLcontext *ctx, int unit, int slot, GLuint replaceargs )
{
   r200ContextPtr rmesa = R200_CONTEXT(ctx);
   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
   GLuint color_combine, alpha_combine;
   GLuint color_scale = rmesa->hw.pix[slot].cmd[PIX_PP_TXCBLEND2] &
      ~(R200_TXC_SCALE_MASK | R200_TXC_OUTPUT_REG_MASK | R200_TXC_TFACTOR_SEL_MASK |
	R200_TXC_TFACTOR1_SEL_MASK);
   GLuint alpha_scale = rmesa->hw.pix[slot].cmd[PIX_PP_TXABLEND2] &
      ~(R200_TXA_DOT_ALPHA | R200_TXA_SCALE_MASK | R200_TXA_OUTPUT_REG_MASK |
	R200_TXA_TFACTOR_SEL_MASK | R200_TXA_TFACTOR1_SEL_MASK);

   /* texUnit->_Current can be NULL if and only if the texture unit is
    * not actually enabled.
    */
   assert( (texUnit->_ReallyEnabled == 0)
	   || (texUnit->_Current != NULL) );

   if ( R200_DEBUG & DEBUG_TEXTURE ) {
      fprintf( stderr, "%s( %p, %d )\n", __FUNCTION__, (void *)ctx, unit );
   }

   /* Set the texture environment state.  Isn't this nice and clean?
    * The chip will automagically set the texture alpha to 0xff when
    * the texture format does not include an alpha component.  This
    * reduces the amount of special-casing we have to do, alpha-only
    * textures being a notable exception.
    */

   color_scale |= ((rmesa->state.texture.unit[unit].outputreg + 1) << R200_TXC_OUTPUT_REG_SHIFT) |
			(unit << R200_TXC_TFACTOR_SEL_SHIFT) |
			(replaceargs << R200_TXC_TFACTOR1_SEL_SHIFT);
   alpha_scale |= ((rmesa->state.texture.unit[unit].outputreg + 1) << R200_TXA_OUTPUT_REG_SHIFT) |
			(unit << R200_TXA_TFACTOR_SEL_SHIFT) |
			(replaceargs << R200_TXA_TFACTOR1_SEL_SHIFT);

   if ( !texUnit->_ReallyEnabled ) {
      assert( unit == 0);
      color_combine = R200_TXC_ARG_A_ZERO | R200_TXC_ARG_B_ZERO
	  | R200_TXC_ARG_C_DIFFUSE_COLOR | R200_TXC_OP_MADD;
      alpha_combine = R200_TXA_ARG_A_ZERO | R200_TXA_ARG_B_ZERO
	  | R200_TXA_ARG_C_DIFFUSE_ALPHA | R200_TXA_OP_MADD;
   }
   else {
      GLuint color_arg[3], alpha_arg[3];
      GLuint i;
      const GLuint numColorArgs = texUnit->_CurrentCombine->_NumArgsRGB;
      const GLuint numAlphaArgs = texUnit->_CurrentCombine->_NumArgsA;
      GLuint RGBshift = texUnit->_CurrentCombine->ScaleShiftRGB;
      GLuint Ashift = texUnit->_CurrentCombine->ScaleShiftA;


      const GLint replaceoprgb =
	 ctx->Texture.Unit[replaceargs]._CurrentCombine->OperandRGB[0] - GL_SRC_COLOR;
      const GLint replaceopa =
	 ctx->Texture.Unit[replaceargs]._CurrentCombine->OperandA[0] - GL_SRC_ALPHA;

      /* Step 1:
       * Extract the color and alpha combine function arguments.
       */
      for ( i = 0 ; i < numColorArgs ; i++ ) {
	 GLint op = texUnit->_CurrentCombine->OperandRGB[i] - GL_SRC_COLOR;
	 const GLint srcRGBi = texUnit->_CurrentCombine->SourceRGB[i];
	 assert(op >= 0);
	 assert(op <= 3);
	 switch ( srcRGBi ) {
	 case GL_TEXTURE:
	    color_arg[i] = r200_register_color[op][unit];
	    break;
	 case GL_CONSTANT:
	    color_arg[i] = r200_tfactor_color[op];
	    break;
	 case GL_PRIMARY_COLOR:
	    color_arg[i] = r200_primary_color[op];
	    break;
	 case GL_PREVIOUS:
	    if (replaceargs != unit) {
	       const GLint srcRGBreplace =
		  ctx->Texture.Unit[replaceargs]._CurrentCombine->SourceRGB[0];
	       if (op >= 2) {
		  op = op ^ replaceopa;
	       }
	       else {
		  op = op ^ replaceoprgb;
	       }
	       switch (srcRGBreplace) {
	       case GL_TEXTURE:
		  color_arg[i] = r200_register_color[op][replaceargs];
		  break;
	       case GL_CONSTANT:
		  color_arg[i] = r200_tfactor1_color[op];
		  break;
	       case GL_PRIMARY_COLOR:
		  color_arg[i] = r200_primary_color[op];
		  break;
	       case GL_PREVIOUS:
		  if (slot == 0)
		     color_arg[i] = r200_primary_color[op];
		  else
		     color_arg[i] = r200_register_color[op]
			[rmesa->state.texture.unit[replaceargs - 1].outputreg];
		  break;
	       case GL_ZERO:
		  color_arg[i] = r200_zero_color[op];
		  break;
	       case GL_ONE:
		  color_arg[i] = r200_zero_color[op+1];
		  break;
	       case GL_TEXTURE0:
	       case GL_TEXTURE1:
	       case GL_TEXTURE2:
	       case GL_TEXTURE3:
	       case GL_TEXTURE4:
	       case GL_TEXTURE5:
		  color_arg[i] = r200_register_color[op][srcRGBreplace - GL_TEXTURE0];
		  break;
	       default:
	       return GL_FALSE;
	       }
	    }
	    else {
	       if (slot == 0)
		  color_arg[i] = r200_primary_color[op];
	       else
		  color_arg[i] = r200_register_color[op]
		     [rmesa->state.texture.unit[unit - 1].outputreg];
            }
	    break;
	 case GL_ZERO:
	    color_arg[i] = r200_zero_color[op];
	    break;
	 case GL_ONE:
	    color_arg[i] = r200_zero_color[op+1];
	    break;
	 case GL_TEXTURE0:
	 case GL_TEXTURE1:
	 case GL_TEXTURE2:
	 case GL_TEXTURE3:
	 case GL_TEXTURE4:
	 case GL_TEXTURE5:
	    color_arg[i] = r200_register_color[op][srcRGBi - GL_TEXTURE0];
	    break;
	 default:
	    return GL_FALSE;
	 }
      }

      for ( i = 0 ; i < numAlphaArgs ; i++ ) {
	 GLint op = texUnit->_CurrentCombine->OperandA[i] - GL_SRC_ALPHA;
	 const GLint srcAi = texUnit->_CurrentCombine->SourceA[i];
	 assert(op >= 0);
	 assert(op <= 1);
	 switch ( srcAi ) {
	 case GL_TEXTURE:
	    alpha_arg[i] = r200_register_alpha[op][unit];
	    break;
	 case GL_CONSTANT:
	    alpha_arg[i] = r200_tfactor_alpha[op];
	    break;
	 case GL_PRIMARY_COLOR:
	    alpha_arg[i] = r200_primary_alpha[op];
	    break;
	 case GL_PREVIOUS:
	    if (replaceargs != unit) {
	       const GLint srcAreplace =
		  ctx->Texture.Unit[replaceargs]._CurrentCombine->SourceA[0];
	       op = op ^ replaceopa;
	       switch (srcAreplace) {
	       case GL_TEXTURE:
		  alpha_arg[i] = r200_register_alpha[op][replaceargs];
		  break;
	       case GL_CONSTANT:
		  alpha_arg[i] = r200_tfactor1_alpha[op];
		  break;
	       case GL_PRIMARY_COLOR:
		  alpha_arg[i] = r200_primary_alpha[op];
		  break;
	       case GL_PREVIOUS:
		  if (slot == 0)
		     alpha_arg[i] = r200_primary_alpha[op];
		  else
		     alpha_arg[i] = r200_register_alpha[op]
			[rmesa->state.texture.unit[replaceargs - 1].outputreg];
		  break;
	       case GL_ZERO:
		  alpha_arg[i] = r200_zero_alpha[op];
		  break;
	       case GL_ONE:
		  alpha_arg[i] = r200_zero_alpha[op+1];
		  break;
	       case GL_TEXTURE0:
	       case GL_TEXTURE1:
	       case GL_TEXTURE2:
	       case GL_TEXTURE3:
	       case GL_TEXTURE4:
	       case GL_TEXTURE5:
		  alpha_arg[i] = r200_register_alpha[op][srcAreplace - GL_TEXTURE0];
		  break;
	       default:
	       return GL_FALSE;
	       }
	    }
	    else {
	       if (slot == 0)
		  alpha_arg[i] = r200_primary_alpha[op];
	       else
		  alpha_arg[i] = r200_register_alpha[op]
		    [rmesa->state.texture.unit[unit - 1].outputreg];
            }
	    break;
	 case GL_ZERO:
	    alpha_arg[i] = r200_zero_alpha[op];
	    break;
	 case GL_ONE:
	    alpha_arg[i] = r200_zero_alpha[op+1];
	    break;
	 case GL_TEXTURE0:
	 case GL_TEXTURE1:
	 case GL_TEXTURE2:
	 case GL_TEXTURE3:
	 case GL_TEXTURE4:
	 case GL_TEXTURE5:
	    alpha_arg[i] = r200_register_alpha[op][srcAi - GL_TEXTURE0];
	    break;
	 default:
	    return GL_FALSE;
	 }
      }

      /* Step 2:
       * Build up the color and alpha combine functions.