src/mesa/main/texparam.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.5
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions 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 MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file texparam.c
  28  *
  29  * glTexParameter-related functions
  30  */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/context.h"
  35 #include "main/enums.h"
  36 #include "main/colormac.h"
  37 #include "main/macros.h"
  38 #include "main/texcompress.h"
  39 #include "main/texparam.h"
  40 #include "main/teximage.h"
  41 #include "main/texstate.h"
  42 #include "shader/prog_instruction.h"
  43
  44
  45 /**
  46  * Check if a coordinate wrap mode is supported for the texture target.
  47  * \return GL_TRUE if legal, GL_FALSE otherwise
  48  */
  49 static GLboolean
  50 validate_texture_wrap_mode(GLcontext * ctx, GLenum target, GLenum wrap)
  51 {
  52    const struct gl_extensions * const e = & ctx->Extensions;
  53
  54    if (wrap == GL_CLAMP || wrap == GL_CLAMP_TO_EDGE ||
  55        (wrap == GL_CLAMP_TO_BORDER && e->ARB_texture_border_clamp)) {
  56       /* any texture target */
  57       return GL_TRUE;
  58    }
  59    else if (target != GL_TEXTURE_RECTANGLE_NV &&
  60             (wrap == GL_REPEAT ||
  61              (wrap == GL_MIRRORED_REPEAT &&
  62               e->ARB_texture_mirrored_repeat) ||
  63              (wrap == GL_MIRROR_CLAMP_EXT &&
  64               (e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp)) ||
  65              (wrap == GL_MIRROR_CLAMP_TO_EDGE_EXT &&
  66               (e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp)) ||
  67              (wrap == GL_MIRROR_CLAMP_TO_BORDER_EXT &&
  68               (e->EXT_texture_mirror_clamp)))) {
  69       /* non-rectangle texture */
  70       return GL_TRUE;
  71    }
  72
  73    _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)", wrap );
  74    return GL_FALSE;
  75 }
  76
  77
  78 /**
  79  * Get current texture object for given target.
  80  * Return NULL if any error.
  81  */
  82 static struct gl_texture_object *
  83 get_texobj(GLcontext *ctx, GLenum target)
  84 {
  85    struct gl_texture_unit *texUnit;
  86
  87    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
  88       _mesa_error(ctx, GL_INVALID_OPERATION, "glTexParameter(current unit)");
  89       return NULL;
  90    }
  91
  92    texUnit = _mesa_get_current_tex_unit(ctx);
  93
  94    switch (target) {
  95    case GL_TEXTURE_1D:
  96       return texUnit->CurrentTex[TEXTURE_1D_INDEX];
  97    case GL_TEXTURE_2D:
  98       return texUnit->CurrentTex[TEXTURE_2D_INDEX];
  99    case GL_TEXTURE_3D:
 100       return texUnit->CurrentTex[TEXTURE_3D_INDEX];
 101    case GL_TEXTURE_CUBE_MAP:
 102       if (ctx->Extensions.ARB_texture_cube_map) {
 103          return texUnit->CurrentTex[TEXTURE_CUBE_INDEX];
 104       }
 105       break;
 106    case GL_TEXTURE_RECTANGLE_NV:
 107       if (ctx->Extensions.NV_texture_rectangle) {
 108          return texUnit->CurrentTex[TEXTURE_RECT_INDEX];
 109       }
 110       break;
 111    case GL_TEXTURE_1D_ARRAY_EXT:
 112       if (ctx->Extensions.MESA_texture_array) {
 113          return texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX];
 114       }
 115       break;
 116    case GL_TEXTURE_2D_ARRAY_EXT:
 117       if (ctx->Extensions.MESA_texture_array) {
 118          return texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX];
 119       }
 120       break;
 121    default:
 122       ;
 123    }
 124
 125    _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(target)");
 126    return NULL;
 127 }
 128
 129
 130 /**
 131  * Convert GL_RED/GREEN/BLUE/ALPHA/ZERO/ONE to SWIZZLE_X/Y/Z/W/ZERO/ONE.
 132  * \return -1 if error.
 133  */
 134 static GLint
 135 comp_to_swizzle(GLenum comp)
 136 {
 137    switch (comp) {
 138    case GL_RED:
 139       return SWIZZLE_X;
 140    case GL_GREEN:
 141       return SWIZZLE_Y;
 142    case GL_BLUE:
 143       return SWIZZLE_Z;
 144    case GL_ALPHA:
 145       return SWIZZLE_W;
 146    case GL_ZERO:
 147       return SWIZZLE_ZERO;
 148    case GL_ONE:
 149       return SWIZZLE_ONE;
 150    default:
 151       return -1;
 152    }
 153 }
 154
 155
 156 static void
 157 set_swizzle_component(GLuint *swizzle, GLuint comp, GLuint swz)
 158 {
 159    ASSERT(comp < 4);
 160    ASSERT(swz <= SWIZZLE_NIL);
 161    {
 162       GLuint mask = 0x7 << (3 * comp);
 163       GLuint s = (*swizzle & ~mask) | (swz << (3 * comp));
 164       *swizzle = s;
 165    }
 166 }
 167
 168
 169 /**
 170  * This is called just prior to changing any texture object state.
 171  * Any pending rendering will be flushed out, we'll set the _NEW_TEXTURE
 172  * state flag and then mark the texture object as 'incomplete' so that any
 173  * per-texture derived state gets recomputed.
 174  */
 175 static INLINE void
 176 flush(GLcontext *ctx, struct gl_texture_object *texObj)
 177 {
 178    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 179    texObj->_Complete = GL_FALSE;
 180 }
 181
 182
 183 /**
 184  * Set an integer-valued texture parameter
 185  * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
 186  */
 187 static GLboolean
 188 set_tex_parameteri(GLcontext *ctx,
 189                    struct gl_texture_object *texObj,
 190                    GLenum pname, const GLint *params)
 191 {
 192    switch (pname) {
 193    case GL_TEXTURE_MIN_FILTER:
 194       if (texObj->MinFilter == params[0])
 195          return GL_FALSE;
 196       switch (params[0]) {
 197       case GL_NEAREST:
 198       case GL_LINEAR:
 199          flush(ctx, texObj);
 200          texObj->MinFilter = params[0];
 201          return GL_TRUE;
 202       case GL_NEAREST_MIPMAP_NEAREST:
 203       case GL_LINEAR_MIPMAP_NEAREST:
 204       case GL_NEAREST_MIPMAP_LINEAR:
 205       case GL_LINEAR_MIPMAP_LINEAR:
 206          if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
 207             flush(ctx, texObj);
 208             texObj->MinFilter = params[0];
 209             return GL_TRUE;
 210          }
 211          /* fall-through */
 212       default:
 213          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
 214                       params[0] );
 215       }
 216       return GL_FALSE;
 217
 218    case GL_TEXTURE_MAG_FILTER:
 219       if (texObj->MagFilter == params[0])
 220          return GL_FALSE;
 221       switch (params[0]) {
 222       case GL_NEAREST:
 223       case GL_LINEAR:
 224          flush(ctx, texObj);
 225          texObj->MagFilter = params[0];
 226          return GL_TRUE;
 227       default:
 228          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
 229                       params[0]);
 230       }
 231       return GL_FALSE;
 232
 233    case GL_TEXTURE_WRAP_S:
 234       if (texObj->WrapS == params[0])
 235          return GL_FALSE;
 236       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
 237          flush(ctx, texObj);
 238          texObj->WrapS = params[0];
 239          return GL_TRUE;
 240       }
 241       return GL_FALSE;
 242
 243    case GL_TEXTURE_WRAP_T:
 244       if (texObj->WrapT == params[0])
 245          return GL_FALSE;
 246       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
 247          flush(ctx, texObj);
 248          texObj->WrapT = params[0];
 249          return GL_TRUE;
 250       }
 251       return GL_FALSE;
 252
 253    case GL_TEXTURE_WRAP_R:
 254       if (texObj->WrapR == params[0])
 255          return GL_FALSE;
 256       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
 257          flush(ctx, texObj);
 258          texObj->WrapR = params[0];
 259          return GL_TRUE;
 260       }
 261       return GL_FALSE;
 262
 263    case GL_TEXTURE_BASE_LEVEL:
 264       if (texObj->BaseLevel == params[0])
 265          return GL_FALSE;
 266       if (params[0] < 0 ||
 267           (texObj->Target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0)) {
 268          _mesa_error(ctx, GL_INVALID_VALUE,
 269                      "glTexParameter(param=%d)", params[0]);
 270          return GL_FALSE;
 271       }
 272       flush(ctx, texObj);
 273       texObj->BaseLevel = params[0];
 274       return GL_TRUE;
 275
 276    case GL_TEXTURE_MAX_LEVEL:
 277       if (texObj->MaxLevel == params[0])
 278          return GL_FALSE;
 279       if (params[0] < 0 || texObj->Target == GL_TEXTURE_RECTANGLE_ARB) {
 280          _mesa_error(ctx, GL_INVALID_OPERATION,
 281                      "glTexParameter(param=%d)", params[0]);
 282          return GL_FALSE;
 283       }
 284       flush(ctx, texObj);
 285       texObj->MaxLevel = params[0];
 286       return GL_TRUE;
 287
 288    case GL_GENERATE_MIPMAP_SGIS:
 289       if (ctx->Extensions.SGIS_generate_mipmap) {
 290          if (texObj->GenerateMipmap != params[0]) {
 291             flush(ctx, texObj);
 292             texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
 293             return GL_TRUE;
 294          }
 295          return GL_FALSE;
 296       }
 297       else {
 298          _mesa_error(ctx, GL_INVALID_ENUM,
 299                      "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
 300       }
 301       return GL_FALSE;
 302
 303    case GL_TEXTURE_COMPARE_MODE_ARB:
 304       if (ctx->Extensions.ARB_shadow &&
 305           (params[0] == GL_NONE ||
 306            params[0] == GL_COMPARE_R_TO_TEXTURE_ARB)) {
 307          if (texObj->CompareMode != params[0]) {
 308             flush(ctx, texObj);
 309             texObj->CompareMode = params[0];
 310             return GL_TRUE;
 311          }
 312          return GL_FALSE;
 313       }
 314       else {
 315          _mesa_error(ctx, GL_INVALID_ENUM,
 316                      "glTexParameter(GL_TEXTURE_COMPARE_MODE_ARB)");
 317       }
 318       return GL_FALSE;
 319
 320    case GL_TEXTURE_COMPARE_FUNC_ARB:
 321       if (ctx->Extensions.ARB_shadow) {
 322          if (texObj->CompareFunc == params[0])
 323             return GL_FALSE;
 324          switch (params[0]) {
 325          case GL_LEQUAL:
 326          case GL_GEQUAL:
 327             flush(ctx, texObj);
 328             texObj->CompareFunc = params[0];
 329             return GL_TRUE;
 330          case GL_EQUAL:
 331          case GL_NOTEQUAL:
 332          case GL_LESS:
 333          case GL_GREATER:
 334          case GL_ALWAYS:
 335          case GL_NEVER:
 336             if (ctx->Extensions.EXT_shadow_funcs) {
 337                flush(ctx, texObj);
 338                texObj->CompareFunc = params[0];
 339                return GL_TRUE;
 340             }
 341             /* fall-through */
 342          default:
 343             _mesa_error(ctx, GL_INVALID_ENUM,
 344                         "glTexParameter(GL_TEXTURE_COMPARE_FUNC_ARB)");
 345          }
 346       }
 347       else {
 348          _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
 349       }
 350       return GL_FALSE;
 351
 352    case GL_DEPTH_TEXTURE_MODE_ARB:
 353       if (ctx->Extensions.ARB_depth_texture &&
 354           (params[0] == GL_LUMINANCE ||
 355            params[0] == GL_INTENSITY ||
 356            params[0] == GL_ALPHA)) {
 357          if (texObj->DepthMode != params[0]) {
 358             flush(ctx, texObj);
 359             texObj->DepthMode = params[0];
 360             return GL_TRUE;
 361          }
 362       }
 363       else {
 364          _mesa_error(ctx, GL_INVALID_ENUM,
 365                      "glTexParameter(GL_DEPTH_TEXTURE_MODE_ARB)");
 366       }
 367       return GL_FALSE;
 368
 369 #ifdef FEATURE_OES_draw_texture
 370    case GL_TEXTURE_CROP_RECT_OES:
 371       texObj->CropRect[0] = params[0];
 372       texObj->CropRect[1] = params[1];
 373       texObj->CropRect[2] = params[2];
 374       texObj->CropRect[3] = params[3];
 375       return GL_TRUE;
 376 #endif
 377
 378    case GL_TEXTURE_SWIZZLE_R_EXT:
 379    case GL_TEXTURE_SWIZZLE_G_EXT:
 380    case GL_TEXTURE_SWIZZLE_B_EXT:
 381    case GL_TEXTURE_SWIZZLE_A_EXT:
 382       if (ctx->Extensions.EXT_texture_swizzle) {
 383          const GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
 384          const GLint swz = comp_to_swizzle(params[0]);
 385          if (swz < 0) {
 386             _mesa_error(ctx, GL_INVALID_OPERATION,
 387                         "glTexParameter(swizzle 0x%x)", params[0]);
 388             return GL_FALSE;
 389          }
 390          ASSERT(comp < 4);
 391          if (swz >= 0) {
 392             flush(ctx, texObj);
 393             texObj->Swizzle[comp] = params[0];
 394             set_swizzle_component(&texObj->_Swizzle, comp, swz);
 395             return GL_TRUE;
 396          }
 397       }
 398       _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
 399       return GL_FALSE;
 400
 401    case GL_TEXTURE_SWIZZLE_RGBA_EXT:
 402       if (ctx->Extensions.EXT_texture_swizzle) {
 403          GLuint comp;
 404          flush(ctx, texObj);
 405          for (comp = 0; comp < 4; comp++) {
 406             const GLint swz = comp_to_swizzle(params[comp]);
 407             if (swz >= 0) {
 408                texObj->Swizzle[comp] = params[comp];
 409                set_swizzle_component(&texObj->_Swizzle, comp, swz);
 410             }
 411             else {
 412                _mesa_error(ctx, GL_INVALID_OPERATION,
 413                            "glTexParameter(swizzle 0x%x)", params[comp]);
 414                return GL_FALSE;
 415             }
 416          }
 417          return GL_TRUE;
 418       }
 419       _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
 420       return GL_FALSE;
 421
 422    default:
 423       _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
 424    }
 425    return GL_FALSE;
 426 }
 427
 428
 429 /**
 430  * Set a float-valued texture parameter
 431  * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
 432  */
 433 static GLboolean
 434 set_tex_parameterf(GLcontext *ctx,
 435                    struct gl_texture_object *texObj,
 436                    GLenum pname, const GLfloat *params)
 437 {
 438    switch (pname) {
 439    case GL_TEXTURE_MIN_LOD:
 440       if (texObj->MinLod == params[0])
 441          return GL_FALSE;
 442       flush(ctx, texObj);
 443       texObj->MinLod = params[0];
 444       return GL_TRUE;
 445
 446    case GL_TEXTURE_MAX_LOD:
 447       if (texObj->MaxLod == params[0])
 448          return GL_FALSE;
 449       flush(ctx, texObj);
 450       texObj->MaxLod = params[0];
 451       return GL_TRUE;
 452
 453    case GL_TEXTURE_PRIORITY:
 454       flush(ctx, texObj);
 455       texObj->Priority = CLAMP(params[0], 0.0F, 1.0F);
 456       return GL_TRUE;
 457
 458    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 459       if (ctx->Extensions.EXT_texture_filter_anisotropic) {
 460          if (texObj->MaxAnisotropy == params[0])
 461             return GL_FALSE;
 462          if (params[0] < 1.0) {
 463             _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 464             return GL_FALSE;
 465          }
 466          flush(ctx, texObj);
 467          /* clamp to max, that's what NVIDIA does */
 468          texObj->MaxAnisotropy = MIN2(params[0],
 469                                       ctx->Const.MaxTextureMaxAnisotropy);
 470          return GL_TRUE;
 471       }
 472       else {
 473          static GLuint count = 0;
 474          if (count++ < 10)
 475             _mesa_error(ctx, GL_INVALID_ENUM,
 476                         "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
 477       }
 478       return GL_FALSE;
 479
 480    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 481       if (ctx->Extensions.ARB_shadow_ambient) {
 482          if (texObj->CompareFailValue != params[0]) {
 483             flush(ctx, texObj);
 484             texObj->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
 485             return GL_TRUE;
 486          }
 487       }
 488       else {
 489          _mesa_error(ctx, GL_INVALID_ENUM,
 490                     "glTexParameter(pname=GL_TEXTURE_COMPARE_FAIL_VALUE_ARB)");
 491       }
 492       return GL_FALSE;
 493
 494    case GL_TEXTURE_LOD_BIAS:
 495       /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
 496       if (ctx->Extensions.EXT_texture_lod_bias) {
 497          if (texObj->LodBias != params[0]) {
 498             flush(ctx, texObj);
 499             texObj->LodBias = params[0];
 500             return GL_TRUE;
 501          }
 502          return GL_FALSE;
 503       }
 504       break;
 505
 506    case GL_TEXTURE_BORDER_COLOR:
 507       flush(ctx, texObj);
 508       texObj->BorderColor[RCOMP] = params[0];
 509       texObj->BorderColor[GCOMP] = params[1];
 510       texObj->BorderColor[BCOMP] = params[2];
 511       texObj->BorderColor[ACOMP] = params[3];
 512       return GL_TRUE;
 513
 514    default:
 515       _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
 516    }
 517    return GL_FALSE;
 518 }
 519
 520
 521 void GLAPIENTRY
 522 _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param)
 523 {
 524    GLboolean need_update;
 525    struct gl_texture_object *texObj;
 526    GET_CURRENT_CONTEXT(ctx);
 527    ASSERT_OUTSIDE_BEGIN_END(ctx);
 528
 529    texObj = get_texobj(ctx, target);
 530    if (!texObj)
 531       return;
 532
 533    switch (pname) {
 534    case GL_TEXTURE_MIN_FILTER:
 535    case GL_TEXTURE_MAG_FILTER:
 536    case GL_TEXTURE_WRAP_S:
 537    case GL_TEXTURE_WRAP_T:
 538    case GL_TEXTURE_WRAP_R:
 539    case GL_TEXTURE_BASE_LEVEL:
 540    case GL_TEXTURE_MAX_LEVEL:
 541    case GL_GENERATE_MIPMAP_SGIS:
 542    case GL_TEXTURE_COMPARE_MODE_ARB:
 543    case GL_TEXTURE_COMPARE_FUNC_ARB:
 544    case GL_DEPTH_TEXTURE_MODE_ARB:
 545       {
 546          /* convert float param to int */
 547          GLint p = (GLint) param;
 548          need_update = set_tex_parameteri(ctx, texObj, pname, &p);
 549       }
 550       break;
 551    default:
 552       /* this will generate an error if pname is illegal */
 553       need_update = set_tex_parameterf(ctx, texObj, pname, &param);
 554    }
 555
 556    if (ctx->Driver.TexParameter && need_update) {
 557       ctx->Driver.TexParameter(ctx, target, texObj, pname, &param);
 558    }
 559 }
 560
 561
 562 void GLAPIENTRY
 563 _mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 564 {
 565    GLboolean need_update;
 566    struct gl_texture_object *texObj;
 567    GET_CURRENT_CONTEXT(ctx);
 568    ASSERT_OUTSIDE_BEGIN_END(ctx);
 569
 570    texObj = get_texobj(ctx, target);
 571    if (!texObj)
 572       return;
 573
 574    switch (pname) {
 575    case GL_TEXTURE_MIN_FILTER:
 576    case GL_TEXTURE_MAG_FILTER:
 577    case GL_TEXTURE_WRAP_S:
 578    case GL_TEXTURE_WRAP_T:
 579    case GL_TEXTURE_WRAP_R:
 580    case GL_TEXTURE_BASE_LEVEL:
 581    case GL_TEXTURE_MAX_LEVEL:
 582    case GL_GENERATE_MIPMAP_SGIS:
 583    case GL_TEXTURE_COMPARE_MODE_ARB:
 584    case GL_TEXTURE_COMPARE_FUNC_ARB:
 585    case GL_DEPTH_TEXTURE_MODE_ARB:
 586       {
 587          /* convert float param to int */
 588          GLint p = (GLint) params[0];
 589          need_update = set_tex_parameteri(ctx, texObj, pname, &p);
 590       }
 591       break;
 592
 593 #ifdef FEATURE_OES_draw_texture
 594    case GL_TEXTURE_CROP_RECT_OES:
 595       {
 596          /* convert float params to int */
 597          GLint iparams[4];
 598          iparams[0] = (GLint) params[0];
 599          iparams[1] = (GLint) params[1];
 600          iparams[2] = (GLint) params[2];
 601          iparams[3] = (GLint) params[3];
 602          need_update = set_tex_parameteri(ctx, target, iparams);
 603       }
 604       break;
 605 #endif
 606
 607    default:
 608       /* this will generate an error if pname is illegal */
 609       need_update = set_tex_parameterf(ctx, texObj, pname, params);
 610    }
 611
 612    if (ctx->Driver.TexParameter && need_update) {
 613       ctx->Driver.TexParameter(ctx, target, texObj, pname, params);
 614    }
 615 }
 616
 617
 618 void GLAPIENTRY
 619 _mesa_TexParameteri(GLenum target, GLenum pname, GLint param)
 620 {
 621    GLboolean need_update;
 622    struct gl_texture_object *texObj;
 623    GET_CURRENT_CONTEXT(ctx);
 624    ASSERT_OUTSIDE_BEGIN_END(ctx);
 625
 626    texObj = get_texobj(ctx, target);
 627    if (!texObj)
 628       return;
 629
 630    switch (pname) {
 631    case GL_TEXTURE_MIN_LOD:
 632    case GL_TEXTURE_MAX_LOD:
 633    case GL_TEXTURE_PRIORITY:
 634    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 635    case GL_TEXTURE_LOD_BIAS:
 636    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 637       {
 638          GLfloat fparam = (GLfloat) param;
 639          /* convert int param to float */
 640          need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
 641       }
 642       break;
 643    default:
 644       /* this will generate an error if pname is illegal */
 645       need_update = set_tex_parameteri(ctx, texObj, pname, &param);
 646    }
 647
 648    if (ctx->Driver.TexParameter && need_update) {
 649       GLfloat fparam = (GLfloat) param;
 650       ctx->Driver.TexParameter(ctx, target, texObj, pname, &fparam);
 651    }
 652 }
 653
 654
 655 void GLAPIENTRY
 656 _mesa_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
 657 {
 658    GLboolean need_update;
 659    struct gl_texture_object *texObj;
 660    GET_CURRENT_CONTEXT(ctx);
 661    ASSERT_OUTSIDE_BEGIN_END(ctx);
 662
 663    texObj = get_texobj(ctx, target);
 664    if (!texObj)
 665       return;
 666
 667    switch (pname) {
 668    case GL_TEXTURE_BORDER_COLOR:
 669       {
 670          /* convert int params to float */
 671          GLfloat fparams[4];
 672          fparams[0] = INT_TO_FLOAT(params[0]);
 673          fparams[1] = INT_TO_FLOAT(params[1]);
 674          fparams[2] = INT_TO_FLOAT(params[2]);
 675          fparams[3] = INT_TO_FLOAT(params[3]);
 676          need_update = set_tex_parameterf(ctx, texObj, pname, fparams);
 677       }
 678       break;
 679    case GL_TEXTURE_MIN_LOD:
 680    case GL_TEXTURE_MAX_LOD:
 681    case GL_TEXTURE_PRIORITY:
 682    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 683    case GL_TEXTURE_LOD_BIAS:
 684    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 685       {
 686          /* convert int param to float */
 687          GLfloat fparam = (GLfloat) params[0];
 688          need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
 689       }
 690       break;
 691    default:
 692       /* this will generate an error if pname is illegal */
 693       need_update = set_tex_parameteri(ctx, texObj, pname, params);
 694    }
 695
 696    if (ctx->Driver.TexParameter && need_update) {
 697       GLfloat fparams[4];
 698       fparams[0] = INT_TO_FLOAT(params[0]);
 699       if (pname == GL_TEXTURE_BORDER_COLOR ||
 700           pname == GL_TEXTURE_CROP_RECT_OES) {
 701          fparams[1] = INT_TO_FLOAT(params[1]);
 702          fparams[2] = INT_TO_FLOAT(params[2]);
 703          fparams[3] = INT_TO_FLOAT(params[3]);
 704       }
 705       ctx->Driver.TexParameter(ctx, target, texObj, pname, fparams);
 706    }
 707 }
 708
 709
 710 void GLAPIENTRY
 711 _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
 712                               GLenum pname, GLfloat *params )
 713 {
 714    GLint iparam;
 715    _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
 716    *params = (GLfloat) iparam;
 717 }
 718
 719
 720 void GLAPIENTRY
 721 _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
 722                               GLenum pname, GLint *params )
 723 {
 724    const struct gl_texture_unit *texUnit;
 725    struct gl_texture_object *texObj;
 726    const struct gl_texture_image *img = NULL;
 727    GLboolean isProxy;
 728    GLint maxLevels;
 729    GET_CURRENT_CONTEXT(ctx);
 730    ASSERT_OUTSIDE_BEGIN_END(ctx);
 731
 732    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
 733       _mesa_error(ctx, GL_INVALID_OPERATION,
 734                   "glGetTexLevelParameteriv(current unit)");
 735       return;
 736    }
 737
 738    texUnit = _mesa_get_current_tex_unit(ctx);
 739
 740    /* this will catch bad target values */
 741    maxLevels = _mesa_max_texture_levels(ctx, target);
 742    if (maxLevels == 0) {
 743       _mesa_error(ctx, GL_INVALID_ENUM,
 744                   "glGetTexLevelParameter[if]v(target=0x%x)", target);
 745       return;
 746    }
 747
 748    if (level < 0 || level >= maxLevels) {
 749       _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
 750       return;
 751    }
 752
 753    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 754    _mesa_lock_texture(ctx, texObj);
 755
 756    img = _mesa_select_tex_image(ctx, texObj, target, level);
 757    if (!img || !img->TexFormat) {
 758       /* undefined texture image */
 759       if (pname == GL_TEXTURE_COMPONENTS)
 760          *params = 1;
 761       else
 762          *params = 0;
 763       goto out;
 764    }
 765
 766    isProxy = _mesa_is_proxy_texture(target);
 767
 768    switch (pname) {
 769       case GL_TEXTURE_WIDTH:
 770          *params = img->Width;
 771          break;
 772       case GL_TEXTURE_HEIGHT:
 773          *params = img->Height;
 774          break;
 775       case GL_TEXTURE_DEPTH:
 776          *params = img->Depth;
 777          break;
 778       case GL_TEXTURE_INTERNAL_FORMAT:
 779          *params = img->InternalFormat;
 780          break;
 781       case GL_TEXTURE_BORDER:
 782          *params = img->Border;
 783          break;
 784       case GL_TEXTURE_RED_SIZE:
 785          if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
 786             *params = img->TexFormat->RedBits;
 787          else
 788             *params = 0;
 789          break;
 790       case GL_TEXTURE_GREEN_SIZE:
 791          if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
 792             *params = img->TexFormat->GreenBits;
 793          else
 794             *params = 0;
 795          break;
 796       case GL_TEXTURE_BLUE_SIZE:
 797          if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
 798             *params = img->TexFormat->BlueBits;
 799          else
 800             *params = 0;
 801          break;
 802       case GL_TEXTURE_ALPHA_SIZE:
 803          if (img->_BaseFormat == GL_ALPHA ||
 804              img->_BaseFormat == GL_LUMINANCE_ALPHA ||
 805              img->_BaseFormat == GL_RGBA)
 806             *params = img->TexFormat->AlphaBits;
 807          else
 808             *params = 0;
 809          break;
 810       case GL_TEXTURE_INTENSITY_SIZE:
 811          if (img->_BaseFormat != GL_INTENSITY)
 812             *params = 0;
 813          else if (img->TexFormat->IntensityBits > 0)
 814             *params = img->TexFormat->IntensityBits;
 815          else /* intensity probably stored as rgb texture */
 816             *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
 817          break;
 818       case GL_TEXTURE_LUMINANCE_SIZE:
 819          if (img->_BaseFormat != GL_LUMINANCE &&
 820              img->_BaseFormat != GL_LUMINANCE_ALPHA)
 821             *params = 0;
 822          else if (img->TexFormat->LuminanceBits > 0)
 823             *params = img->TexFormat->LuminanceBits;
 824          else /* luminance probably stored as rgb texture */
 825             *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
 826          break;
 827       case GL_TEXTURE_INDEX_SIZE_EXT:
 828          if (img->_BaseFormat == GL_COLOR_INDEX)
 829             *params = img->TexFormat->IndexBits;
 830          else
 831             *params = 0;
 832          break;
 833       case GL_TEXTURE_DEPTH_SIZE_ARB:
 834          if (ctx->Extensions.ARB_depth_texture)
 835             *params = img->TexFormat->DepthBits;
 836          else
 837             _mesa_error(ctx, GL_INVALID_ENUM,
 838                         "glGetTexLevelParameter[if]v(pname)");
 839          break;
 840       case GL_TEXTURE_STENCIL_SIZE_EXT:
 841          if (ctx->Extensions.EXT_packed_depth_stencil ||
 842              ctx->Extensions.ARB_framebuffer_object) {
 843             *params = img->TexFormat->StencilBits;
 844          }
 845          else {
 846             _mesa_error(ctx, GL_INVALID_ENUM,
 847                         "glGetTexLevelParameter[if]v(pname)");
 848          }
 849          break;
 850
 851       /* GL_ARB_texture_compression */
 852       case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
 853          if (img->IsCompressed && !isProxy) {
 854             /* Don't use ctx->Driver.CompressedTextureSize() since that
 855              * may returned a padded hardware size.
 856              */
 857             *params = _mesa_compressed_texture_size(ctx, img->Width,
 858                                                     img->Height, img->Depth,
 859                                                     img->TexFormat->MesaFormat);
 860          }
 861          else {
 862             _mesa_error(ctx, GL_INVALID_OPERATION,
 863                         "glGetTexLevelParameter[if]v(pname)");
 864          }
 865          break;
 866       case GL_TEXTURE_COMPRESSED:
 867          *params = (GLint) img->IsCompressed;
 868          break;
 869
 870       /* GL_ARB_texture_float */
 871       case GL_TEXTURE_RED_TYPE_ARB:
 872          if (ctx->Extensions.ARB_texture_float) {
 873             *params = img->TexFormat->RedBits ? img->TexFormat->DataType : GL_NONE;
 874          }
 875          else {
 876             _mesa_error(ctx, GL_INVALID_ENUM,
 877                         "glGetTexLevelParameter[if]v(pname)");
 878          }
 879          break;
 880       case GL_TEXTURE_GREEN_TYPE_ARB:
 881          if (ctx->Extensions.ARB_texture_float) {
 882             *params = img->TexFormat->GreenBits ? img->TexFormat->DataType : GL_NONE;
 883          }
 884          else {
 885             _mesa_error(ctx, GL_INVALID_ENUM,
 886                         "glGetTexLevelParameter[if]v(pname)");
 887          }
 888          break;
 889       case GL_TEXTURE_BLUE_TYPE_ARB:
 890          if (ctx->Extensions.ARB_texture_float) {
 891             *params = img->TexFormat->BlueBits ? img->TexFormat->DataType : GL_NONE;
 892          }
 893          else {
 894             _mesa_error(ctx, GL_INVALID_ENUM,
 895                         "glGetTexLevelParameter[if]v(pname)");
 896          }
 897          break;
 898       case GL_TEXTURE_ALPHA_TYPE_ARB:
 899          if (ctx->Extensions.ARB_texture_float) {
 900             *params = img->TexFormat->AlphaBits ? img->TexFormat->DataType : GL_NONE;
 901          }
 902          else {
 903             _mesa_error(ctx, GL_INVALID_ENUM,
 904                         "glGetTexLevelParameter[if]v(pname)");
 905          }
 906          break;
 907       case GL_TEXTURE_LUMINANCE_TYPE_ARB:
 908          if (ctx->Extensions.ARB_texture_float) {
 909             *params = img->TexFormat->LuminanceBits ? img->TexFormat->DataType : GL_NONE;
 910          }
 911          else {
 912             _mesa_error(ctx, GL_INVALID_ENUM,
 913                         "glGetTexLevelParameter[if]v(pname)");
 914          }
 915          break;
 916       case GL_TEXTURE_INTENSITY_TYPE_ARB:
 917          if (ctx->Extensions.ARB_texture_float) {
 918             *params = img->TexFormat->IntensityBits ? img->TexFormat->DataType : GL_NONE;
 919          }
 920          else {
 921             _mesa_error(ctx, GL_INVALID_ENUM,
 922                         "glGetTexLevelParameter[if]v(pname)");
 923          }
 924          break;
 925       case GL_TEXTURE_DEPTH_TYPE_ARB:
 926          if (ctx->Extensions.ARB_texture_float) {
 927             *params = img->TexFormat->DepthBits ? img->TexFormat->DataType : GL_NONE;
 928          }
 929          else {
 930             _mesa_error(ctx, GL_INVALID_ENUM,
 931                         "glGetTexLevelParameter[if]v(pname)");
 932          }
 933          break;
 934
 935       default:
 936          _mesa_error(ctx, GL_INVALID_ENUM,
 937                      "glGetTexLevelParameter[if]v(pname)");
 938    }
 939
 940  out:
 941    _mesa_unlock_texture(ctx, texObj);
 942 }
 943
 944
 945
 946 void GLAPIENTRY
 947 _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
 948 {
 949    struct gl_texture_unit *texUnit;
 950    struct gl_texture_object *obj;
 951    GLboolean error = GL_FALSE;
 952    GET_CURRENT_CONTEXT(ctx);
 953    ASSERT_OUTSIDE_BEGIN_END(ctx);
 954
 955    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
 956       _mesa_error(ctx, GL_INVALID_OPERATION,
 957                   "glGetTexParameterfv(current unit)");
 958       return;
 959    }
 960
 961    texUnit = _mesa_get_current_tex_unit(ctx);
 962
 963    obj = _mesa_select_tex_object(ctx, texUnit, target);
 964    if (!obj) {
 965       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
 966       return;
 967    }
 968
 969    _mesa_lock_texture(ctx, obj);
 970    switch (pname) {
 971       case GL_TEXTURE_MAG_FILTER:
 972          *params = ENUM_TO_FLOAT(obj->MagFilter);
 973          break;
 974       case GL_TEXTURE_MIN_FILTER:
 975          *params = ENUM_TO_FLOAT(obj->MinFilter);
 976          break;
 977       case GL_TEXTURE_WRAP_S:
 978          *params = ENUM_TO_FLOAT(obj->WrapS);
 979          break;
 980       case GL_TEXTURE_WRAP_T:
 981          *params = ENUM_TO_FLOAT(obj->WrapT);
 982          break;
 983       case GL_TEXTURE_WRAP_R:
 984          *params = ENUM_TO_FLOAT(obj->WrapR);
 985          break;
 986       case GL_TEXTURE_BORDER_COLOR:
 987          params[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
 988          params[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
 989          params[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
 990          params[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
 991          break;
 992       case GL_TEXTURE_RESIDENT:
 993          {
 994             GLboolean resident;
 995             if (ctx->Driver.IsTextureResident)
 996                resident = ctx->Driver.IsTextureResident(ctx, obj);
 997             else
 998                resident = GL_TRUE;
 999             *params = ENUM_TO_FLOAT(resident);
1000          }
1001          break;
1002       case GL_TEXTURE_PRIORITY:
1003          *params = obj->Priority;
1004          break;
1005       case GL_TEXTURE_MIN_LOD:
1006          *params = obj->MinLod;
1007          break;
1008       case GL_TEXTURE_MAX_LOD:
1009          *params = obj->MaxLod;
1010          break;
1011       case GL_TEXTURE_BASE_LEVEL:
1012          *params = (GLfloat) obj->BaseLevel;
1013          break;
1014       case GL_TEXTURE_MAX_LEVEL:
1015          *params = (GLfloat) obj->MaxLevel;
1016          break;
1017       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1018          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1019             *params = obj->MaxAnisotropy;
1020          }
1021          else
1022             error = GL_TRUE;
1023          break;
1024       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
1025          if (ctx->Extensions.ARB_shadow_ambient) {
1026             *params = obj->CompareFailValue;
1027          }
1028          else
1029             error = GL_TRUE;
1030          break;
1031       case GL_GENERATE_MIPMAP_SGIS:
1032          if (ctx->Extensions.SGIS_generate_mipmap) {
1033             *params = (GLfloat) obj->GenerateMipmap;
1034          }
1035          else
1036             error = GL_TRUE;
1037          break;
1038       case GL_TEXTURE_COMPARE_MODE_ARB:
1039          if (ctx->Extensions.ARB_shadow) {
1040             *params = (GLfloat) obj->CompareMode;
1041          }
1042          else
1043             error = GL_TRUE;
1044          break;
1045       case GL_TEXTURE_COMPARE_FUNC_ARB:
1046          if (ctx->Extensions.ARB_shadow) {
1047             *params = (GLfloat) obj->CompareFunc;
1048          }
1049          else
1050             error = GL_TRUE;
1051          break;
1052       case GL_DEPTH_TEXTURE_MODE_ARB:
1053          if (ctx->Extensions.ARB_depth_texture) {
1054             *params = (GLfloat) obj->DepthMode;
1055          }
1056          else
1057             error = GL_TRUE;
1058          break;
1059       case GL_TEXTURE_LOD_BIAS:
1060          if (ctx->Extensions.EXT_texture_lod_bias) {
1061             *params = obj->LodBias;
1062          }
1063          else
1064             error = GL_TRUE;
1065          break;
1066 #ifdef FEATURE_OES_draw_texture
1067       case GL_TEXTURE_CROP_RECT_OES:
1068          params[0] = obj->CropRect[0];
1069          params[1] = obj->CropRect[1];
1070          params[2] = obj->CropRect[2];
1071          params[3] = obj->CropRect[3];
1072          break;
1073 #endif
1074
1075       case GL_TEXTURE_SWIZZLE_R_EXT:
1076       case GL_TEXTURE_SWIZZLE_G_EXT:
1077       case GL_TEXTURE_SWIZZLE_B_EXT:
1078       case GL_TEXTURE_SWIZZLE_A_EXT:
1079          if (ctx->Extensions.EXT_texture_swizzle) {
1080             GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
1081             *params = (GLfloat) obj->Swizzle[comp];
1082          }
1083          else {
1084             error = GL_TRUE;
1085          }
1086          break;
1087
1088       case GL_TEXTURE_SWIZZLE_RGBA_EXT:
1089          if (ctx->Extensions.EXT_texture_swizzle) {
1090             GLuint comp;
1091             for (comp = 0; comp < 4; comp++) {
1092                params[comp] = (GLfloat) obj->Swizzle[comp];
1093             }
1094          }
1095          else {
1096             error = GL_TRUE;
1097          }
1098          break;
1099
1100       default:
1101          error = GL_TRUE;
1102          break;
1103    }
1104
1105    if (error)
1106       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)",
1107                   pname);
1108
1109    _mesa_unlock_texture(ctx, obj);
1110 }
1111
1112
1113 void GLAPIENTRY
1114 _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1115 {
1116    struct gl_texture_unit *texUnit;
1117    struct gl_texture_object *obj;
1118    GLboolean error = GL_FALSE;
1119    GET_CURRENT_CONTEXT(ctx);
1120    ASSERT_OUTSIDE_BEGIN_END(ctx);
1121
1122    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
1123       _mesa_error(ctx, GL_INVALID_OPERATION,
1124                   "glGetTexParameteriv(current unit)");
1125       return;
1126    }
1127
1128    texUnit = _mesa_get_current_tex_unit(ctx);
1129
1130    obj = _mesa_select_tex_object(ctx, texUnit, target);
1131    if (!obj) {
1132       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
1133       return;
1134    }
1135
1136    switch (pname) {
1137       case GL_TEXTURE_MAG_FILTER:
1138          *params = (GLint) obj->MagFilter;
1139          break;;
1140       case GL_TEXTURE_MIN_FILTER:
1141          *params = (GLint) obj->MinFilter;
1142          break;;
1143       case GL_TEXTURE_WRAP_S:
1144          *params = (GLint) obj->WrapS;
1145          break;;
1146       case GL_TEXTURE_WRAP_T:
1147          *params = (GLint) obj->WrapT;
1148          break;;
1149       case GL_TEXTURE_WRAP_R:
1150          *params = (GLint) obj->WrapR;
1151          break;;
1152       case GL_TEXTURE_BORDER_COLOR:
1153          {
1154             GLfloat b[4];
1155             b[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
1156             b[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
1157             b[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
1158             b[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
1159             params[0] = FLOAT_TO_INT(b[0]);
1160             params[1] = FLOAT_TO_INT(b[1]);
1161             params[2] = FLOAT_TO_INT(b[2]);
1162             params[3] = FLOAT_TO_INT(b[3]);
1163          }
1164          break;;
1165       case GL_TEXTURE_RESIDENT:
1166          {
1167             GLboolean resident;
1168             if (ctx->Driver.IsTextureResident)
1169                resident = ctx->Driver.IsTextureResident(ctx, obj);
1170             else
1171                resident = GL_TRUE;
1172             *params = (GLint) resident;
1173          }
1174          break;;
1175       case GL_TEXTURE_PRIORITY:
1176          *params = FLOAT_TO_INT(obj->Priority);
1177          break;;
1178       case GL_TEXTURE_MIN_LOD:
1179          *params = (GLint) obj->MinLod;
1180          break;;
1181       case GL_TEXTURE_MAX_LOD:
1182          *params = (GLint) obj->MaxLod;
1183          break;;
1184       case GL_TEXTURE_BASE_LEVEL:
1185          *params = obj->BaseLevel;
1186          break;;
1187       case GL_TEXTURE_MAX_LEVEL:
1188          *params = obj->MaxLevel;
1189          break;;
1190       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1191          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1192             *params = (GLint) obj->MaxAnisotropy;
1193          }
1194          else {
1195             error = GL_TRUE;
1196          }
1197          break;
1198       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
1199          if (ctx->Extensions.ARB_shadow_ambient) {
1200             *params = (GLint) FLOAT_TO_INT(obj->CompareFailValue);
1201          }
1202          else {
1203             error = GL_TRUE;
1204          }
1205          break;
1206       case GL_GENERATE_MIPMAP_SGIS:
1207          if (ctx->Extensions.SGIS_generate_mipmap) {
1208             *params = (GLint) obj->GenerateMipmap;
1209          }
1210          else {
1211             error = GL_TRUE;
1212          }
1213          break;
1214       case GL_TEXTURE_COMPARE_MODE_ARB:
1215          if (ctx->Extensions.ARB_shadow) {
1216             *params = (GLint) obj->CompareMode;
1217          }
1218          else {
1219             error = GL_TRUE;
1220          }
1221          break;
1222       case GL_TEXTURE_COMPARE_FUNC_ARB:
1223          if (ctx->Extensions.ARB_shadow) {
1224             *params = (GLint) obj->CompareFunc;
1225          }
1226          else {
1227             error = GL_TRUE;
1228          }
1229          break;
1230       case GL_DEPTH_TEXTURE_MODE_ARB:
1231          if (ctx->Extensions.ARB_depth_texture) {
1232             *params = (GLint) obj->DepthMode;
1233          }
1234          else {
1235             error = GL_TRUE;
1236          }
1237          break;
1238       case GL_TEXTURE_LOD_BIAS:
1239          if (ctx->Extensions.EXT_texture_lod_bias) {
1240             *params = (GLint) obj->LodBias;
1241          }
1242          else {
1243             error = GL_TRUE;
1244          }
1245          break;
1246 #ifdef FEATURE_OES_draw_texture
1247       case GL_TEXTURE_CROP_RECT_OES:
1248          params[0] = obj->CropRect[0];
1249          params[1] = obj->CropRect[1];
1250          params[2] = obj->CropRect[2];
1251          params[3] = obj->CropRect[3];
1252          break;
1253 #endif
1254       case GL_TEXTURE_SWIZZLE_R_EXT:
1255       case GL_TEXTURE_SWIZZLE_G_EXT:
1256       case GL_TEXTURE_SWIZZLE_B_EXT:
1257       case GL_TEXTURE_SWIZZLE_A_EXT:
1258          if (ctx->Extensions.EXT_texture_swizzle) {
1259             GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
1260             *params = obj->Swizzle[comp];
1261          }
1262          else {
1263             error = GL_TRUE;
1264          }
1265          break;
1266
1267       case GL_TEXTURE_SWIZZLE_RGBA_EXT:
1268          if (ctx->Extensions.EXT_texture_swizzle) {
1269             COPY_4V(params, obj->Swizzle);
1270          }
1271          else {
1272             error = GL_TRUE;
1273          }
1274          break;
1275
1276       default:
1277          ; /* silence warnings */
1278    }
1279
1280    if (error)
1281       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)",
1282                   pname);
1283
1284    _mesa_unlock_texture(ctx, obj);
1285 }