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