src/mesa/drivers/dri/i915/i830_texblend.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "main/glheader.h"
  29 #include "main/macros.h"
  30 #include "main/mtypes.h"
  31 #include "main/enums.h"
  32 #include "main/mm.h"
  33
  34 #include "intel_screen.h"
  35 #include "intel_tex.h"
  36
  37 #include "i830_context.h"
  38 #include "i830_reg.h"
  39
  40
  41 /* ================================================================
  42  * Texture combine functions
  43  */
  44 static GLuint
  45 pass_through(GLuint * state, GLuint blendUnit)
  46 {
  47    state[0] = (_3DSTATE_MAP_BLEND_OP_CMD(blendUnit) |
  48                TEXPIPE_COLOR |
  49                ENABLE_TEXOUTPUT_WRT_SEL |
  50                TEXOP_OUTPUT_CURRENT |
  51                DISABLE_TEX_CNTRL_STAGE |
  52                TEXOP_SCALE_1X | TEXOP_MODIFY_PARMS | TEXBLENDOP_ARG1);
  53    state[1] = (_3DSTATE_MAP_BLEND_OP_CMD(blendUnit) |
  54                TEXPIPE_ALPHA |
  55                ENABLE_TEXOUTPUT_WRT_SEL |
  56                TEXOP_OUTPUT_CURRENT |
  57                TEXOP_SCALE_1X | TEXOP_MODIFY_PARMS | TEXBLENDOP_ARG1);
  58    state[2] = (_3DSTATE_MAP_BLEND_ARG_CMD(blendUnit) |
  59                TEXPIPE_COLOR |
  60                TEXBLEND_ARG1 |
  61                TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_CURRENT);
  62    state[3] = (_3DSTATE_MAP_BLEND_ARG_CMD(blendUnit) |
  63                TEXPIPE_ALPHA |
  64                TEXBLEND_ARG1 |
  65                TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_CURRENT);
  66
  67    return 4;
  68 }
  69
  70 static GLuint
  71 emit_factor(GLuint blendUnit, GLuint * state, GLuint count,
  72             const GLfloat * factor)
  73 {
  74    GLubyte r, g, b, a;
  75    GLuint col;
  76
  77    if (0)
  78       fprintf(stderr, "emit constant %d: %.2f %.2f %.2f %.2f\n",
  79               blendUnit, factor[0], factor[1], factor[2], factor[3]);
  80
  81    UNCLAMPED_FLOAT_TO_UBYTE(r, factor[0]);
  82    UNCLAMPED_FLOAT_TO_UBYTE(g, factor[1]);
  83    UNCLAMPED_FLOAT_TO_UBYTE(b, factor[2]);
  84    UNCLAMPED_FLOAT_TO_UBYTE(a, factor[3]);
  85
  86    col = ((a << 24) | (r << 16) | (g << 8) | b);
  87
  88    state[count++] = _3DSTATE_COLOR_FACTOR_N_CMD(blendUnit);
  89    state[count++] = col;
  90
  91    return count;
  92 }
  93
  94
  95 static inline GLuint
  96 GetTexelOp(GLint unit)
  97 {
  98    switch (unit) {
  99    case 0:
 100       return TEXBLENDARG_TEXEL0;
 101    case 1:
 102       return TEXBLENDARG_TEXEL1;
 103    case 2:
 104       return TEXBLENDARG_TEXEL2;
 105    case 3:
 106       return TEXBLENDARG_TEXEL3;
 107    default:
 108       return TEXBLENDARG_TEXEL0;
 109    }
 110 }
 111
 112
 113 /**
 114  * Calculate the hardware instuctions to setup the current texture enviromnemt
 115  * settings.  Since \c gl_texture_unit::_CurrentCombine is used, both
 116  * "classic" texture enviroments and GL_ARB_texture_env_combine type texture
 117  * environments are treated identically.
 118  *
 119  * \todo
 120  * This function should return \c bool.  When \c false is returned,
 121  * it means that an environment is selected that the hardware cannot do.  This
 122  * is the way the Radeon and R200 drivers work.
 123  *
 124  * \todo
 125  * Looking at i830_3d_regs.h, it seems the i830 can do part of
 126  * GL_ATI_texture_env_combine3.  It can handle using \c GL_ONE and
 127  * \c GL_ZERO as combine inputs (which the code already supports).  It can
 128  * also handle the \c GL_MODULATE_ADD_ATI mode.  Is it worth investigating
 129  * partial support for the extension?
 130  */
 131 GLuint
 132 i830SetTexEnvCombine(struct i830_context * i830,
 133                      const struct gl_tex_env_combine_state * combine,
 134                      GLint blendUnit,
 135                      GLuint texel_op, GLuint * state, const GLfloat * factor)
 136 {
 137    const GLuint numColorArgs = combine->_NumArgsRGB;
 138    GLuint numAlphaArgs = combine->_NumArgsA;
 139
 140    GLuint blendop;
 141    GLuint ablendop;
 142    GLuint args_RGB[3];
 143    GLuint args_A[3];
 144    GLuint rgb_shift;
 145    GLuint alpha_shift;
 146    bool need_factor = 0;
 147    int i;
 148    unsigned used;
 149    static const GLuint tex_blend_rgb[3] = {
 150       TEXPIPE_COLOR | TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS,
 151       TEXPIPE_COLOR | TEXBLEND_ARG2 | TEXBLENDARG_MODIFY_PARMS,
 152       TEXPIPE_COLOR | TEXBLEND_ARG0 | TEXBLENDARG_MODIFY_PARMS,
 153    };
 154    static const GLuint tex_blend_a[3] = {
 155       TEXPIPE_ALPHA | TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS,
 156       TEXPIPE_ALPHA | TEXBLEND_ARG2 | TEXBLENDARG_MODIFY_PARMS,
 157       TEXPIPE_ALPHA | TEXBLEND_ARG0 | TEXBLENDARG_MODIFY_PARMS,
 158    };
 159
 160    if (INTEL_DEBUG & DEBUG_TEXTURE)
 161       fprintf(stderr, "%s\n", __func__);
 162
 163
 164    /* The EXT version of the DOT3 extension does not support the
 165     * scale factor, but the ARB version (and the version in OpenGL
 166     * 1.3) does.
 167     */
 168    switch (combine->ModeRGB) {
 169    case GL_DOT3_RGB_EXT:
 170       alpha_shift = combine->ScaleShiftA;
 171       rgb_shift = 0;
 172       break;
 173
 174    case GL_DOT3_RGBA_EXT:
 175       alpha_shift = 0;
 176       rgb_shift = 0;
 177       break;
 178
 179    default:
 180       rgb_shift = combine->ScaleShiftRGB;
 181       alpha_shift = combine->ScaleShiftA;
 182       break;
 183    }
 184
 185
 186    switch (combine->ModeRGB) {
 187    case GL_REPLACE:
 188       blendop = TEXBLENDOP_ARG1;
 189       break;
 190    case GL_MODULATE:
 191       blendop = TEXBLENDOP_MODULATE;
 192       break;
 193    case GL_ADD:
 194       blendop = TEXBLENDOP_ADD;
 195       break;
 196    case GL_ADD_SIGNED:
 197       blendop = TEXBLENDOP_ADDSIGNED;
 198       break;
 199    case GL_INTERPOLATE:
 200       blendop = TEXBLENDOP_BLEND;
 201       break;
 202    case GL_SUBTRACT:
 203       blendop = TEXBLENDOP_SUBTRACT;
 204       break;
 205    case GL_DOT3_RGB_EXT:
 206    case GL_DOT3_RGB:
 207       blendop = TEXBLENDOP_DOT3;
 208       break;
 209    case GL_DOT3_RGBA_EXT:
 210    case GL_DOT3_RGBA:
 211       blendop = TEXBLENDOP_DOT4;
 212       break;
 213    default:
 214       return pass_through(state, blendUnit);
 215    }
 216
 217    blendop |= (rgb_shift << TEXOP_SCALE_SHIFT);
 218
 219
 220    /* Handle RGB args */
 221    for (i = 0; i < 3; i++) {
 222       switch (combine->SourceRGB[i]) {
 223       case GL_TEXTURE:
 224          args_RGB[i] = texel_op;
 225          break;
 226       case GL_TEXTURE0:
 227       case GL_TEXTURE1:
 228       case GL_TEXTURE2:
 229       case GL_TEXTURE3:
 230          args_RGB[i] = GetTexelOp(combine->SourceRGB[i] - GL_TEXTURE0);
 231          break;
 232       case GL_CONSTANT:
 233          args_RGB[i] = TEXBLENDARG_FACTOR_N;
 234          need_factor = 1;
 235          break;
 236       case GL_PRIMARY_COLOR:
 237          args_RGB[i] = TEXBLENDARG_DIFFUSE;
 238          break;
 239       case GL_PREVIOUS:
 240          args_RGB[i] = TEXBLENDARG_CURRENT;
 241          break;
 242       default:
 243          return pass_through(state, blendUnit);
 244       }
 245
 246       switch (combine->OperandRGB[i]) {
 247       case GL_SRC_COLOR:
 248          args_RGB[i] |= 0;
 249          break;
 250       case GL_ONE_MINUS_SRC_COLOR:
 251          args_RGB[i] |= TEXBLENDARG_INV_ARG;
 252          break;
 253       case GL_SRC_ALPHA:
 254          args_RGB[i] |= TEXBLENDARG_REPLICATE_ALPHA;
 255          break;
 256       case GL_ONE_MINUS_SRC_ALPHA:
 257          args_RGB[i] |= (TEXBLENDARG_REPLICATE_ALPHA | TEXBLENDARG_INV_ARG);
 258          break;
 259       default:
 260          return pass_through(state, blendUnit);
 261       }
 262    }
 263
 264
 265    /* Need to knobble the alpha calculations of TEXBLENDOP_DOT4 to
 266     * match the spec.  Can't use DOT3 as it won't propogate values
 267     * into alpha as required:
 268     *
 269     * Note - the global factor is set up with alpha == .5, so
 270     * the alpha part of the DOT4 calculation should be zero.
 271     */
 272    if (combine->ModeRGB == GL_DOT3_RGBA_EXT ||
 273        combine->ModeRGB == GL_DOT3_RGBA) {
 274       ablendop = TEXBLENDOP_DOT4;
 275       numAlphaArgs = 2;
 276       args_A[0] = TEXBLENDARG_FACTOR;   /* the global factor */
 277       args_A[1] = TEXBLENDARG_FACTOR;
 278       args_A[2] = TEXBLENDARG_FACTOR;
 279    }
 280    else {
 281       switch (combine->ModeA) {
 282       case GL_REPLACE:
 283          ablendop = TEXBLENDOP_ARG1;
 284          break;
 285       case GL_MODULATE:
 286          ablendop = TEXBLENDOP_MODULATE;
 287          break;
 288       case GL_ADD:
 289          ablendop = TEXBLENDOP_ADD;
 290          break;
 291       case GL_ADD_SIGNED:
 292          ablendop = TEXBLENDOP_ADDSIGNED;
 293          break;
 294       case GL_INTERPOLATE:
 295          ablendop = TEXBLENDOP_BLEND;
 296          break;
 297       case GL_SUBTRACT:
 298          ablendop = TEXBLENDOP_SUBTRACT;
 299          break;
 300       default:
 301          return pass_through(state, blendUnit);
 302       }
 303
 304
 305       ablendop |= (alpha_shift << TEXOP_SCALE_SHIFT);
 306
 307       /* Handle A args */
 308       for (i = 0; i < 3; i++) {
 309          switch (combine->SourceA[i]) {
 310          case GL_TEXTURE:
 311             args_A[i] = texel_op;
 312             break;
 313          case GL_TEXTURE0:
 314          case GL_TEXTURE1:
 315          case GL_TEXTURE2:
 316          case GL_TEXTURE3:
 317             args_A[i] = GetTexelOp(combine->SourceA[i] - GL_TEXTURE0);
 318             break;
 319          case GL_CONSTANT:
 320             args_A[i] = TEXBLENDARG_FACTOR_N;
 321             need_factor = 1;
 322             break;
 323          case GL_PRIMARY_COLOR:
 324             args_A[i] = TEXBLENDARG_DIFFUSE;
 325             break;
 326          case GL_PREVIOUS:
 327             args_A[i] = TEXBLENDARG_CURRENT;
 328             break;
 329          default:
 330             return pass_through(state, blendUnit);
 331          }
 332
 333          switch (combine->OperandA[i]) {
 334          case GL_SRC_ALPHA:
 335             args_A[i] |= 0;
 336             break;
 337          case GL_ONE_MINUS_SRC_ALPHA:
 338             args_A[i] |= TEXBLENDARG_INV_ARG;
 339             break;
 340          default:
 341             return pass_through(state, blendUnit);
 342          }
 343       }
 344    }
 345
 346
 347
 348    /* Native Arg1 == Arg0 in GL_EXT_texture_env_combine spec */
 349    /* Native Arg2 == Arg1 in GL_EXT_texture_env_combine spec */
 350    /* Native Arg0 == Arg2 in GL_EXT_texture_env_combine spec */
 351
 352    /* When we render we need to figure out which is the last really enabled
 353     * tex unit, and put last stage on it
 354     */
 355
 356
 357    /* Build color & alpha pipelines */
 358
 359    used = 0;
 360    state[used++] = (_3DSTATE_MAP_BLEND_OP_CMD(blendUnit) |
 361                     TEXPIPE_COLOR |
 362                     ENABLE_TEXOUTPUT_WRT_SEL |
 363                     TEXOP_OUTPUT_CURRENT |
 364                     DISABLE_TEX_CNTRL_STAGE | TEXOP_MODIFY_PARMS | blendop);
 365    state[used++] = (_3DSTATE_MAP_BLEND_OP_CMD(blendUnit) |
 366                     TEXPIPE_ALPHA |
 367                     ENABLE_TEXOUTPUT_WRT_SEL |
 368                     TEXOP_OUTPUT_CURRENT | TEXOP_MODIFY_PARMS | ablendop);
 369
 370    for (i = 0; i < numColorArgs; i++) {
 371       state[used++] = (_3DSTATE_MAP_BLEND_ARG_CMD(blendUnit) |
 372                        tex_blend_rgb[i] | args_RGB[i]);
 373    }
 374
 375    for (i = 0; i < numAlphaArgs; i++) {
 376       state[used++] = (_3DSTATE_MAP_BLEND_ARG_CMD(blendUnit) |
 377                        tex_blend_a[i] | args_A[i]);
 378    }
 379
 380
 381    if (need_factor)
 382       return emit_factor(blendUnit, state, used, factor);
 383    else
 384       return used;
 385 }
 386
 387
 388 static void
 389 emit_texblend(struct i830_context *i830, GLuint unit, GLuint blendUnit,
 390               bool last_stage)
 391 {
 392    struct gl_texture_unit *texUnit = &i830->intel.ctx.Texture.Unit[unit];
 393    GLuint tmp[I830_TEXBLEND_SIZE], tmp_sz;
 394
 395
 396    if (0)
 397       fprintf(stderr, "%s unit %d\n", __func__, unit);
 398
 399    /* Update i830->state.TexBlend
 400     */
 401    tmp_sz = i830SetTexEnvCombine(i830, texUnit->_CurrentCombine, blendUnit,
 402                                  GetTexelOp(unit), tmp, texUnit->EnvColor);
 403
 404    if (last_stage)
 405       tmp[0] |= TEXOP_LAST_STAGE;
 406
 407    if (tmp_sz != i830->state.TexBlendWordsUsed[blendUnit] ||
 408        memcmp(tmp, i830->state.TexBlend[blendUnit],
 409               tmp_sz * sizeof(GLuint))) {
 410
 411       I830_STATECHANGE(i830, I830_UPLOAD_TEXBLEND(blendUnit));
 412       memcpy(i830->state.TexBlend[blendUnit], tmp, tmp_sz * sizeof(GLuint));
 413       i830->state.TexBlendWordsUsed[blendUnit] = tmp_sz;
 414    }
 415
 416    I830_ACTIVESTATE(i830, I830_UPLOAD_TEXBLEND(blendUnit), true);
 417 }
 418
 419 static void
 420 emit_passthrough(struct i830_context *i830)
 421 {
 422    GLuint tmp[I830_TEXBLEND_SIZE], tmp_sz;
 423    GLuint unit = 0;
 424
 425    tmp_sz = pass_through(tmp, unit);
 426    tmp[0] |= TEXOP_LAST_STAGE;
 427
 428    if (tmp_sz != i830->state.TexBlendWordsUsed[unit] ||
 429        memcmp(tmp, i830->state.TexBlend[unit], tmp_sz * sizeof(GLuint))) {
 430
 431       I830_STATECHANGE(i830, I830_UPLOAD_TEXBLEND(unit));
 432       memcpy(i830->state.TexBlend[unit], tmp, tmp_sz * sizeof(GLuint));
 433       i830->state.TexBlendWordsUsed[unit] = tmp_sz;
 434    }
 435
 436    I830_ACTIVESTATE(i830, I830_UPLOAD_TEXBLEND(unit), true);
 437 }
 438
 439 void
 440 i830EmitTextureBlend(struct i830_context *i830)
 441 {
 442    struct gl_context *ctx = &i830->intel.ctx;
 443    GLuint unit, blendunit = 0;
 444
 445    I830_ACTIVESTATE(i830, I830_UPLOAD_TEXBLEND_ALL, false);
 446
 447    if (ctx->Texture._MaxEnabledTexImageUnit != -1) {
 448       for (unit = 0; unit <= ctx->Texture._MaxEnabledTexImageUnit; unit++)
 449          if (ctx->Texture.Unit[unit]._Current)
 450             emit_texblend(i830, unit, blendunit++,
 451                           unit == ctx->Texture._MaxEnabledTexImageUnit);
 452    } else {
 453       emit_passthrough(i830);
 454    }
 455 }