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