src/mesa/main/texenv.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file texenv.c
  28  *
  29  * glTexEnv-related functions
  30  */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/context.h"
  35 #include "main/blend.h"
  36 #include "main/enums.h"
  37 #include "main/macros.h"
  38 #include "main/mtypes.h"
  39 #include "main/state.h"
  40 #include "main/texenv.h"
  41 #include "main/texstate.h"
  42
  43
  44 #define TE_ERROR(errCode, msg, value)                           \
  45    _mesa_error(ctx, errCode, msg, _mesa_enum_to_string(value));
  46
  47
  48 /** Set texture env mode */
  49 static void
  50 set_env_mode(struct gl_context *ctx,
  51              struct gl_fixedfunc_texture_unit *texUnit,
  52              GLenum mode)
  53 {
  54    GLboolean legal;
  55
  56    if (texUnit->EnvMode == mode)
  57       return;
  58
  59    switch (mode) {
  60    case GL_MODULATE:
  61    case GL_BLEND:
  62    case GL_DECAL:
  63    case GL_REPLACE:
  64    case GL_ADD:
  65    case GL_COMBINE:
  66       legal = GL_TRUE;
  67       break;
  68    case GL_REPLACE_EXT:
  69       mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */
  70       legal = GL_TRUE;
  71       break;
  72    case GL_COMBINE4_NV:
  73       legal = ctx->Extensions.NV_texture_env_combine4;
  74       break;
  75    default:
  76       legal = GL_FALSE;
  77    }
  78
  79    if (legal) {
  80       FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
  81       texUnit->EnvMode = mode;
  82    }
  83    else {
  84       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
  85    }
  86 }
  87
  88
  89 static void
  90 set_env_color(struct gl_context *ctx,
  91               struct gl_fixedfunc_texture_unit *texUnit,
  92               const GLfloat *color)
  93 {
  94    if (TEST_EQ_4V(color, texUnit->EnvColorUnclamped))
  95       return;
  96    FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
  97    COPY_4FV(texUnit->EnvColorUnclamped, color);
  98    texUnit->EnvColor[0] = CLAMP(color[0], 0.0F, 1.0F);
  99    texUnit->EnvColor[1] = CLAMP(color[1], 0.0F, 1.0F);
 100    texUnit->EnvColor[2] = CLAMP(color[2], 0.0F, 1.0F);
 101    texUnit->EnvColor[3] = CLAMP(color[3], 0.0F, 1.0F);
 102 }
 103
 104
 105 /** Set an RGB or A combiner mode/function */
 106 static void
 107 set_combiner_mode(struct gl_context *ctx,
 108                   struct gl_fixedfunc_texture_unit *texUnit,
 109                   GLenum pname, GLenum mode)
 110 {
 111    GLboolean legal;
 112
 113    switch (mode) {
 114    case GL_REPLACE:
 115    case GL_MODULATE:
 116    case GL_ADD:
 117    case GL_ADD_SIGNED:
 118    case GL_INTERPOLATE:
 119       legal = GL_TRUE;
 120       break;
 121    case GL_SUBTRACT:
 122       legal = ctx->Extensions.ARB_texture_env_combine;
 123       break;
 124    case GL_DOT3_RGB_EXT:
 125    case GL_DOT3_RGBA_EXT:
 126       legal = (ctx->API == API_OPENGL_COMPAT &&
 127                ctx->Extensions.EXT_texture_env_dot3 &&
 128                pname == GL_COMBINE_RGB);
 129       break;
 130    case GL_DOT3_RGB:
 131    case GL_DOT3_RGBA:
 132       legal = (ctx->Extensions.ARB_texture_env_dot3 &&
 133                pname == GL_COMBINE_RGB);
 134       break;
 135    case GL_MODULATE_ADD_ATI:
 136    case GL_MODULATE_SIGNED_ADD_ATI:
 137    case GL_MODULATE_SUBTRACT_ATI:
 138       legal = (ctx->API == API_OPENGL_COMPAT &&
 139                ctx->Extensions.ATI_texture_env_combine3);
 140       break;
 141    default:
 142       legal = GL_FALSE;
 143    }
 144
 145    if (!legal) {
 146       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 147       return;
 148    }
 149
 150    switch (pname) {
 151    case GL_COMBINE_RGB:
 152       if (texUnit->Combine.ModeRGB == mode)
 153          return;
 154       FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 155       texUnit->Combine.ModeRGB = mode;
 156       break;
 157
 158    case GL_COMBINE_ALPHA:
 159       if (texUnit->Combine.ModeA == mode)
 160          return;
 161       FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 162       texUnit->Combine.ModeA = mode;
 163       break;
 164    default:
 165       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 166    }
 167 }
 168
 169
 170
 171 /** Set an RGB or A combiner source term */
 172 static void
 173 set_combiner_source(struct gl_context *ctx,
 174                     struct gl_fixedfunc_texture_unit *texUnit,
 175                     GLenum pname, GLenum param)
 176 {
 177    GLuint term;
 178    GLboolean alpha, legal;
 179
 180    /*
 181     * Translate pname to (term, alpha).
 182     *
 183     * The enums were given sequential values for a reason.
 184     */
 185    switch (pname) {
 186    case GL_SOURCE0_RGB:
 187    case GL_SOURCE1_RGB:
 188    case GL_SOURCE2_RGB:
 189    case GL_SOURCE3_RGB_NV:
 190       term = pname - GL_SOURCE0_RGB;
 191       alpha = GL_FALSE;
 192       break;
 193    case GL_SOURCE0_ALPHA:
 194    case GL_SOURCE1_ALPHA:
 195    case GL_SOURCE2_ALPHA:
 196    case GL_SOURCE3_ALPHA_NV:
 197       term = pname - GL_SOURCE0_ALPHA;
 198       alpha = GL_TRUE;
 199       break;
 200    default:
 201       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 202       return;
 203    }
 204
 205    if ((term == 3) && (ctx->API != API_OPENGL_COMPAT
 206                        || !ctx->Extensions.NV_texture_env_combine4)) {
 207       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 208       return;
 209    }
 210
 211    assert(term < MAX_COMBINER_TERMS);
 212
 213    /*
 214     * Error-check param (the source term)
 215     */
 216    switch (param) {
 217    case GL_TEXTURE:
 218    case GL_CONSTANT:
 219    case GL_PRIMARY_COLOR:
 220    case GL_PREVIOUS:
 221       legal = GL_TRUE;
 222       break;
 223    case GL_TEXTURE0:
 224    case GL_TEXTURE1:
 225    case GL_TEXTURE2:
 226    case GL_TEXTURE3:
 227    case GL_TEXTURE4:
 228    case GL_TEXTURE5:
 229    case GL_TEXTURE6:
 230    case GL_TEXTURE7:
 231       legal = (ctx->Extensions.ARB_texture_env_crossbar &&
 232                param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits);
 233       break;
 234    case GL_ZERO:
 235       legal = (ctx->API == API_OPENGL_COMPAT &&
 236                (ctx->Extensions.ATI_texture_env_combine3 ||
 237                 ctx->Extensions.NV_texture_env_combine4));
 238       break;
 239    case GL_ONE:
 240       legal = (ctx->API == API_OPENGL_COMPAT &&
 241                ctx->Extensions.ATI_texture_env_combine3);
 242       break;
 243    default:
 244       legal = GL_FALSE;
 245    }
 246
 247    if (!legal) {
 248       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
 249       return;
 250    }
 251
 252    FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 253
 254    if (alpha)
 255       texUnit->Combine.SourceA[term] = param;
 256    else
 257       texUnit->Combine.SourceRGB[term] = param;
 258 }
 259
 260
 261 /** Set an RGB or A combiner operand term */
 262 static void
 263 set_combiner_operand(struct gl_context *ctx,
 264                      struct gl_fixedfunc_texture_unit *texUnit,
 265                      GLenum pname, GLenum param)
 266 {
 267    GLuint term;
 268    GLboolean alpha, legal;
 269
 270    /* The enums were given sequential values for a reason.
 271     */
 272    switch (pname) {
 273    case GL_OPERAND0_RGB:
 274    case GL_OPERAND1_RGB:
 275    case GL_OPERAND2_RGB:
 276    case GL_OPERAND3_RGB_NV:
 277       term = pname - GL_OPERAND0_RGB;
 278       alpha = GL_FALSE;
 279       break;
 280    case GL_OPERAND0_ALPHA:
 281    case GL_OPERAND1_ALPHA:
 282    case GL_OPERAND2_ALPHA:
 283    case GL_OPERAND3_ALPHA_NV:
 284       term = pname - GL_OPERAND0_ALPHA;
 285       alpha = GL_TRUE;
 286       break;
 287    default:
 288       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 289       return;
 290    }
 291
 292    if ((term == 3) && (ctx->API != API_OPENGL_COMPAT
 293                        || !ctx->Extensions.NV_texture_env_combine4)) {
 294       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 295       return;
 296    }
 297
 298    assert(term < MAX_COMBINER_TERMS);
 299
 300    /*
 301     * Error-check param (the source operand)
 302     */
 303    switch (param) {
 304    case GL_SRC_COLOR:
 305    case GL_ONE_MINUS_SRC_COLOR:
 306       /* The color input can only be used with GL_OPERAND[01]_RGB in the EXT
 307        * version.  In the ARB and NV versions and OpenGL ES 1.x they can be
 308        * used for any RGB operand.
 309        */
 310       legal = !alpha
 311          && ((term < 2) || ctx->Extensions.ARB_texture_env_combine
 312              || ctx->Extensions.NV_texture_env_combine4);
 313       break;
 314    case GL_ONE_MINUS_SRC_ALPHA:
 315       /* GL_ONE_MINUS_SRC_ALPHA can only be used with
 316        * GL_OPERAND[01]_(RGB|ALPHA) in the EXT version.  In the ARB and NV
 317        * versions and OpenGL ES 1.x it can be used for any operand.
 318        */
 319       legal = (term < 2) || ctx->Extensions.ARB_texture_env_combine
 320          || ctx->Extensions.NV_texture_env_combine4;
 321       break;
 322    case GL_SRC_ALPHA:
 323       legal = GL_TRUE;
 324       break;
 325    default:
 326       legal = GL_FALSE;
 327    }
 328
 329    if (!legal) {
 330       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
 331       return;
 332    }
 333
 334    FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 335
 336    if (alpha)
 337       texUnit->Combine.OperandA[term] = param;
 338    else
 339       texUnit->Combine.OperandRGB[term] = param;
 340 }
 341
 342
 343 static void
 344 set_combiner_scale(struct gl_context *ctx,
 345                    struct gl_fixedfunc_texture_unit *texUnit,
 346                    GLenum pname, GLfloat scale)
 347 {
 348    GLuint shift;
 349
 350    if (scale == 1.0F) {
 351       shift = 0;
 352    }
 353    else if (scale == 2.0F) {
 354       shift = 1;
 355    }
 356    else if (scale == 4.0F) {
 357       shift = 2;
 358    }
 359    else {
 360       _mesa_error( ctx, GL_INVALID_VALUE,
 361                    "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
 362       return;
 363    }
 364
 365    switch (pname) {
 366    case GL_RGB_SCALE:
 367       if (texUnit->Combine.ScaleShiftRGB == shift)
 368          return;
 369       FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 370       texUnit->Combine.ScaleShiftRGB = shift;
 371       break;
 372    case GL_ALPHA_SCALE:
 373       if (texUnit->Combine.ScaleShiftA == shift)
 374          return;
 375       FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 376       texUnit->Combine.ScaleShiftA = shift;
 377       break;
 378    default:
 379       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 380    }
 381 }
 382
 383
 384
 385 void GLAPIENTRY
 386 _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
 387 {
 388    const GLint iparam0 = (GLint) param[0];
 389    GLuint maxUnit;
 390    GET_CURRENT_CONTEXT(ctx);
 391
 392    maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
 393       ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits;
 394    if (ctx->Texture.CurrentUnit >= maxUnit) {
 395       _mesa_error(ctx, GL_INVALID_OPERATION, "glTexEnvfv(current unit)");
 396       return;
 397    }
 398
 399    if (target == GL_TEXTURE_ENV) {
 400       struct gl_fixedfunc_texture_unit *texUnit =
 401          _mesa_get_current_fixedfunc_tex_unit(ctx);
 402
 403       /* The GL spec says that we should report an error if the unit is greater
 404        * than GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, but in practice, only
 405        * fixed-function units are usable. This is probably a spec bug.
 406        * Ignore glTexEnv(GL_TEXTURE_ENV) calls for non-fixed-func units,
 407        * because we don't want to process calls that have no effect.
 408        */
 409       if (!texUnit)
 410          return;
 411
 412       switch (pname) {
 413       case GL_TEXTURE_ENV_MODE:
 414          set_env_mode(ctx, texUnit, (GLenum) iparam0);
 415          break;
 416       case GL_TEXTURE_ENV_COLOR:
 417          set_env_color(ctx, texUnit, param);
 418          break;
 419       case GL_COMBINE_RGB:
 420       case GL_COMBINE_ALPHA:
 421          set_combiner_mode(ctx, texUnit, pname, (GLenum) iparam0);
 422          break;
 423       case GL_SOURCE0_RGB:
 424       case GL_SOURCE1_RGB:
 425       case GL_SOURCE2_RGB:
 426       case GL_SOURCE3_RGB_NV:
 427       case GL_SOURCE0_ALPHA:
 428       case GL_SOURCE1_ALPHA:
 429       case GL_SOURCE2_ALPHA:
 430       case GL_SOURCE3_ALPHA_NV:
 431          set_combiner_source(ctx, texUnit, pname, (GLenum) iparam0);
 432          break;
 433       case GL_OPERAND0_RGB:
 434       case GL_OPERAND1_RGB:
 435       case GL_OPERAND2_RGB:
 436       case GL_OPERAND3_RGB_NV:
 437       case GL_OPERAND0_ALPHA:
 438       case GL_OPERAND1_ALPHA:
 439       case GL_OPERAND2_ALPHA:
 440       case GL_OPERAND3_ALPHA_NV:
 441          set_combiner_operand(ctx, texUnit, pname, (GLenum) iparam0);
 442          break;
 443       case GL_RGB_SCALE:
 444       case GL_ALPHA_SCALE:
 445          set_combiner_scale(ctx, texUnit, pname, param[0]);
 446          break;
 447       default:
 448          _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
 449          return;
 450       }
 451    }
 452    else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
 453       struct gl_texture_unit *texUnit =
 454          _mesa_get_current_tex_unit(ctx);
 455
 456       if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
 457          if (texUnit->LodBias == param[0])
 458             return;
 459          FLUSH_VERTICES(ctx, _NEW_TEXTURE_OBJECT);
 460          texUnit->LodBias = param[0];
 461       }
 462       else {
 463          TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 464          return;
 465       }
 466    }
 467    else if (target == GL_POINT_SPRITE_NV) {
 468       /* GL_ARB_point_sprite / GL_NV_point_sprite */
 469       if (!ctx->Extensions.NV_point_sprite
 470           && !ctx->Extensions.ARB_point_sprite) {
 471          _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
 472          return;
 473       }
 474       if (pname == GL_COORD_REPLACE_NV) {
 475          /* It's kind of weird to set point state via glTexEnv,
 476           * but that's what the spec calls for.
 477           */
 478          if (iparam0 == GL_TRUE) {
 479             if (ctx->Point.CoordReplace & (1u << ctx->Texture.CurrentUnit))
 480                return;
 481             ctx->Point.CoordReplace |= (1u << ctx->Texture.CurrentUnit);
 482          } else if (iparam0 == GL_FALSE) {
 483             if (~(ctx->Point.CoordReplace) & (1u << ctx->Texture.CurrentUnit))
 484                return;
 485             ctx->Point.CoordReplace &= ~(1u << ctx->Texture.CurrentUnit);
 486          } else {
 487             _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0);
 488             return;
 489          }
 490          FLUSH_VERTICES(ctx, _NEW_POINT);
 491       }
 492       else {
 493          _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
 494          return;
 495       }
 496    }
 497    else {
 498       _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(target=%s)",
 499                   _mesa_enum_to_string(target));
 500       return;
 501    }
 502
 503    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
 504       _mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n",
 505                   _mesa_enum_to_string(target),
 506                   _mesa_enum_to_string(pname),
 507                   *param,
 508                   _mesa_enum_to_string((GLenum) iparam0));
 509
 510    /* Tell device driver about the new texture environment */
 511    if (ctx->Driver.TexEnv) {
 512       ctx->Driver.TexEnv(ctx, target, pname, param);
 513    }
 514 }
 515
 516
 517 void GLAPIENTRY
 518 _mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
 519 {
 520    GLfloat p[4];
 521    p[0] = param;
 522    p[1] = p[2] = p[3] = 0.0;
 523    _mesa_TexEnvfv( target, pname, p );
 524 }
 525
 526
 527
 528 void GLAPIENTRY
 529 _mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
 530 {
 531    GLfloat p[4];
 532    p[0] = (GLfloat) param;
 533    p[1] = p[2] = p[3] = 0.0;
 534    _mesa_TexEnvfv( target, pname, p );
 535 }
 536
 537
 538 void GLAPIENTRY
 539 _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
 540 {
 541    GLfloat p[4];
 542    if (pname == GL_TEXTURE_ENV_COLOR) {
 543       p[0] = INT_TO_FLOAT( param[0] );
 544       p[1] = INT_TO_FLOAT( param[1] );
 545       p[2] = INT_TO_FLOAT( param[2] );
 546       p[3] = INT_TO_FLOAT( param[3] );
 547    }
 548    else {
 549       p[0] = (GLfloat) param[0];
 550       p[1] = p[2] = p[3] = 0;  /* init to zero, just to be safe */
 551    }
 552    _mesa_TexEnvfv( target, pname, p );
 553 }
 554
 555
 556
 557 /**
 558  * Helper for glGetTexEnvi/f()
 559  * \return  value of queried pname or -1 if error.
 560  */
 561 static GLint
 562 get_texenvi(struct gl_context *ctx,
 563             const struct gl_fixedfunc_texture_unit *texUnit,
 564             GLenum pname)
 565 {
 566    switch (pname) {
 567    case GL_TEXTURE_ENV_MODE:
 568       return texUnit->EnvMode;
 569       break;
 570    case GL_COMBINE_RGB:
 571       return texUnit->Combine.ModeRGB;
 572    case GL_COMBINE_ALPHA:
 573       return texUnit->Combine.ModeA;
 574    case GL_SOURCE0_RGB:
 575    case GL_SOURCE1_RGB:
 576    case GL_SOURCE2_RGB: {
 577       const unsigned rgb_idx = pname - GL_SOURCE0_RGB;
 578       return texUnit->Combine.SourceRGB[rgb_idx];
 579    }
 580    case GL_SOURCE3_RGB_NV:
 581       if (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.NV_texture_env_combine4) {
 582          return texUnit->Combine.SourceRGB[3];
 583       }
 584       else {
 585          _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 586       }
 587       break;
 588    case GL_SOURCE0_ALPHA:
 589    case GL_SOURCE1_ALPHA:
 590    case GL_SOURCE2_ALPHA: {
 591       const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;
 592       return texUnit->Combine.SourceA[alpha_idx];
 593    }
 594    case GL_SOURCE3_ALPHA_NV:
 595       if (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.NV_texture_env_combine4) {
 596          return texUnit->Combine.SourceA[3];
 597       }
 598       else {
 599          _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 600       }
 601       break;
 602    case GL_OPERAND0_RGB:
 603    case GL_OPERAND1_RGB:
 604    case GL_OPERAND2_RGB: {
 605       const unsigned op_rgb = pname - GL_OPERAND0_RGB;
 606       return texUnit->Combine.OperandRGB[op_rgb];
 607    }
 608    case GL_OPERAND3_RGB_NV:
 609       if (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.NV_texture_env_combine4) {
 610          return texUnit->Combine.OperandRGB[3];
 611       }
 612       else {
 613          _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 614       }
 615       break;
 616    case GL_OPERAND0_ALPHA:
 617    case GL_OPERAND1_ALPHA:
 618    case GL_OPERAND2_ALPHA: {
 619       const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;
 620       return texUnit->Combine.OperandA[op_alpha];
 621    }
 622    case GL_OPERAND3_ALPHA_NV:
 623       if (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.NV_texture_env_combine4) {
 624          return texUnit->Combine.OperandA[3];
 625       }
 626       else {
 627          _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 628       }
 629       break;
 630    case GL_RGB_SCALE:
 631       return 1 << texUnit->Combine.ScaleShiftRGB;
 632    case GL_ALPHA_SCALE:
 633       return 1 << texUnit->Combine.ScaleShiftA;
 634    default:
 635       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 636       break;
 637    }
 638
 639    return -1; /* error */
 640 }
 641
 642
 643
 644 void GLAPIENTRY
 645 _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
 646 {
 647    GLuint maxUnit;
 648    GET_CURRENT_CONTEXT(ctx);
 649
 650    maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
 651       ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits;
 652    if (ctx->Texture.CurrentUnit >= maxUnit) {
 653       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnvfv(current unit)");
 654       return;
 655    }
 656
 657    if (target == GL_TEXTURE_ENV) {
 658       struct gl_fixedfunc_texture_unit *texUnit =
 659          _mesa_get_current_fixedfunc_tex_unit(ctx);
 660
 661       /* The GL spec says that we should report an error if the unit is greater
 662        * than GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, but in practice, only
 663        * fixed-function units are usable. This is probably a spec bug.
 664        * Ignore calls for non-fixed-func units, because we don't process
 665        * glTexEnv for them either.
 666        */
 667       if (!texUnit)
 668          return;
 669
 670       if (pname == GL_TEXTURE_ENV_COLOR) {
 671          if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
 672             _mesa_update_state(ctx);
 673          if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
 674             COPY_4FV( params, texUnit->EnvColor );
 675          else
 676             COPY_4FV( params, texUnit->EnvColorUnclamped );
 677       }
 678       else {
 679          GLint val = get_texenvi(ctx, texUnit, pname);
 680          if (val >= 0) {
 681             *params = (GLfloat) val;
 682          }
 683       }
 684    }
 685    else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
 686       const struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
 687
 688       if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
 689          *params = texUnit->LodBias;
 690       }
 691       else {
 692          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
 693          return;
 694       }
 695    }
 696    else if (target == GL_POINT_SPRITE_NV) {
 697       /* GL_ARB_point_sprite / GL_NV_point_sprite */
 698       if (!ctx->Extensions.NV_point_sprite
 699           && !ctx->Extensions.ARB_point_sprite) {
 700          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
 701          return;
 702       }
 703       if (pname == GL_COORD_REPLACE_NV) {
 704          if (ctx->Point.CoordReplace & (1u << ctx->Texture.CurrentUnit))
 705             *params = 1.0f;
 706          else
 707             *params = 0.0f;
 708       }
 709       else {
 710          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
 711          return;
 712       }
 713    }
 714    else {
 715       _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
 716       return;
 717    }
 718 }
 719
 720
 721 void GLAPIENTRY
 722 _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
 723 {
 724    GLuint maxUnit;
 725    GET_CURRENT_CONTEXT(ctx);
 726
 727    maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
 728       ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits;
 729    if (ctx->Texture.CurrentUnit >= maxUnit) {
 730       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnviv(current unit)");
 731       return;
 732    }
 733
 734    if (target == GL_TEXTURE_ENV) {
 735       struct gl_fixedfunc_texture_unit *texUnit =
 736          _mesa_get_current_fixedfunc_tex_unit(ctx);
 737
 738       /* The GL spec says that we should report an error if the unit is greater
 739        * than GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, but in practice, only
 740        * fixed-function units are usable. This is probably a spec bug.
 741        * Ignore calls for non-fixed-func units, because we don't process
 742        * glTexEnv for them either.
 743        */
 744       if (!texUnit)
 745          return;
 746
 747       if (pname == GL_TEXTURE_ENV_COLOR) {
 748          params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
 749          params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
 750          params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
 751          params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
 752       }
 753       else {
 754          GLint val = get_texenvi(ctx, texUnit, pname);
 755          if (val >= 0) {
 756             *params = val;
 757          }
 758       }
 759    }
 760    else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
 761       const struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
 762
 763       if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
 764          *params = (GLint) texUnit->LodBias;
 765       }
 766       else {
 767          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
 768          return;
 769       }
 770    }
 771    else if (target == GL_POINT_SPRITE_NV) {
 772       /* GL_ARB_point_sprite / GL_NV_point_sprite */
 773       if (!ctx->Extensions.NV_point_sprite
 774           && !ctx->Extensions.ARB_point_sprite) {
 775          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
 776          return;
 777       }
 778       if (pname == GL_COORD_REPLACE_NV) {
 779          if (ctx->Point.CoordReplace & (1u << ctx->Texture.CurrentUnit))
 780             *params = GL_TRUE;
 781          else
 782             *params = GL_FALSE;
 783       }
 784       else {
 785          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
 786          return;
 787       }
 788    }
 789    else {
 790       _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
 791       return;
 792    }
 793 }
 794