Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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/colormac.h"
  35. #include "main/context.h"
  36. #include "main/formats.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 "program/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(struct gl_context * 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 (and record the error).
  81.  * Note that this is different from _mesa_select_tex_object() in that proxy
  82.  * targets are not accepted.
  83.  * Only the glGetTexLevelParameter() functions accept proxy targets.
  84.  */
  85. static struct gl_texture_object *
  86. get_texobj(struct gl_context *ctx, GLenum target, GLboolean get)
  87. {
  88.    struct gl_texture_unit *texUnit;
  89.  
  90.    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxCombinedTextureImageUnits) {
  91.       _mesa_error(ctx, GL_INVALID_OPERATION,
  92.                   "gl%sTexParameter(current unit)", get ? "Get" : "");
  93.       return NULL;
  94.    }
  95.  
  96.    texUnit = _mesa_get_current_tex_unit(ctx);
  97.  
  98.    switch (target) {
  99.    case GL_TEXTURE_1D:
  100.       return texUnit->CurrentTex[TEXTURE_1D_INDEX];
  101.    case GL_TEXTURE_2D:
  102.       return texUnit->CurrentTex[TEXTURE_2D_INDEX];
  103.    case GL_TEXTURE_3D:
  104.       return texUnit->CurrentTex[TEXTURE_3D_INDEX];
  105.    case GL_TEXTURE_CUBE_MAP:
  106.       if (ctx->Extensions.ARB_texture_cube_map) {
  107.          return texUnit->CurrentTex[TEXTURE_CUBE_INDEX];
  108.       }
  109.       break;
  110.    case GL_TEXTURE_RECTANGLE_NV:
  111.       if (ctx->Extensions.NV_texture_rectangle) {
  112.          return texUnit->CurrentTex[TEXTURE_RECT_INDEX];
  113.       }
  114.       break;
  115.    case GL_TEXTURE_1D_ARRAY_EXT:
  116.       if (ctx->Extensions.MESA_texture_array) {
  117.          return texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX];
  118.       }
  119.       break;
  120.    case GL_TEXTURE_2D_ARRAY_EXT:
  121.       if (ctx->Extensions.MESA_texture_array) {
  122.          return texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX];
  123.       }
  124.       break;
  125.    default:
  126.       ;
  127.    }
  128.  
  129.    _mesa_error(ctx, GL_INVALID_ENUM,
  130.                   "gl%sTexParameter(target)", get ? "Get" : "");
  131.    return NULL;
  132. }
  133.  
  134.  
  135. /**
  136.  * Convert GL_RED/GREEN/BLUE/ALPHA/ZERO/ONE to SWIZZLE_X/Y/Z/W/ZERO/ONE.
  137.  * \return -1 if error.
  138.  */
  139. static GLint
  140. comp_to_swizzle(GLenum comp)
  141. {
  142.    switch (comp) {
  143.    case GL_RED:
  144.       return SWIZZLE_X;
  145.    case GL_GREEN:
  146.       return SWIZZLE_Y;
  147.    case GL_BLUE:
  148.       return SWIZZLE_Z;
  149.    case GL_ALPHA:
  150.       return SWIZZLE_W;
  151.    case GL_ZERO:
  152.       return SWIZZLE_ZERO;
  153.    case GL_ONE:
  154.       return SWIZZLE_ONE;
  155.    default:
  156.       return -1;
  157.    }
  158. }
  159.  
  160.  
  161. static void
  162. set_swizzle_component(GLuint *swizzle, GLuint comp, GLuint swz)
  163. {
  164.    ASSERT(comp < 4);
  165.    ASSERT(swz <= SWIZZLE_NIL);
  166.    {
  167.       GLuint mask = 0x7 << (3 * comp);
  168.       GLuint s = (*swizzle & ~mask) | (swz << (3 * comp));
  169.       *swizzle = s;
  170.    }
  171. }
  172.  
  173.  
  174. /**
  175.  * This is called just prior to changing any texture object state.
  176.  * Any pending rendering will be flushed out, we'll set the _NEW_TEXTURE
  177.  * state flag and then mark the texture object as 'incomplete' so that any
  178.  * per-texture derived state gets recomputed.
  179.  */
  180. static INLINE void
  181. flush(struct gl_context *ctx, struct gl_texture_object *texObj)
  182. {
  183.    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  184.    texObj->_Complete = GL_FALSE;
  185. }
  186.  
  187.  
  188. /**
  189.  * Set an integer-valued texture parameter
  190.  * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
  191.  */
  192. static GLboolean
  193. set_tex_parameteri(struct gl_context *ctx,
  194.                    struct gl_texture_object *texObj,
  195.                    GLenum pname, const GLint *params)
  196. {
  197.    switch (pname) {
  198.    case GL_TEXTURE_MIN_FILTER:
  199.       if (texObj->MinFilter == params[0])
  200.          return GL_FALSE;
  201.       switch (params[0]) {
  202.       case GL_NEAREST:
  203.       case GL_LINEAR:
  204.          flush(ctx, texObj);
  205.          texObj->MinFilter = params[0];
  206.          return GL_TRUE;
  207.       case GL_NEAREST_MIPMAP_NEAREST:
  208.       case GL_LINEAR_MIPMAP_NEAREST:
  209.       case GL_NEAREST_MIPMAP_LINEAR:
  210.       case GL_LINEAR_MIPMAP_LINEAR:
  211.          if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
  212.             flush(ctx, texObj);
  213.             texObj->MinFilter = params[0];
  214.             return GL_TRUE;
  215.          }
  216.          /* fall-through */
  217.       default:
  218.          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
  219.                       params[0] );
  220.       }
  221.       return GL_FALSE;
  222.  
  223.    case GL_TEXTURE_MAG_FILTER:
  224.       if (texObj->MagFilter == params[0])
  225.          return GL_FALSE;
  226.       switch (params[0]) {
  227.       case GL_NEAREST:
  228.       case GL_LINEAR:
  229.          flush(ctx, texObj);
  230.          texObj->MagFilter = params[0];
  231.          return GL_TRUE;
  232.       default:
  233.          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
  234.                       params[0]);
  235.       }
  236.       return GL_FALSE;
  237.  
  238.    case GL_TEXTURE_WRAP_S:
  239.       if (texObj->WrapS == params[0])
  240.          return GL_FALSE;
  241.       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
  242.          flush(ctx, texObj);
  243.          texObj->WrapS = params[0];
  244.          return GL_TRUE;
  245.       }
  246.       return GL_FALSE;
  247.  
  248.    case GL_TEXTURE_WRAP_T:
  249.       if (texObj->WrapT == params[0])
  250.          return GL_FALSE;
  251.       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
  252.          flush(ctx, texObj);
  253.          texObj->WrapT = params[0];
  254.          return GL_TRUE;
  255.       }
  256.       return GL_FALSE;
  257.  
  258.    case GL_TEXTURE_WRAP_R:
  259.       if (texObj->WrapR == params[0])
  260.          return GL_FALSE;
  261.       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
  262.          flush(ctx, texObj);
  263.          texObj->WrapR = params[0];
  264.          return GL_TRUE;
  265.       }
  266.       return GL_FALSE;
  267.  
  268.    case GL_TEXTURE_BASE_LEVEL:
  269.       if (texObj->BaseLevel == params[0])
  270.          return GL_FALSE;
  271.       if (params[0] < 0 ||
  272.           (texObj->Target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0)) {
  273.          _mesa_error(ctx, GL_INVALID_VALUE,
  274.                      "glTexParameter(param=%d)", params[0]);
  275.          return GL_FALSE;
  276.       }
  277.       flush(ctx, texObj);
  278.       texObj->BaseLevel = params[0];
  279.       return GL_TRUE;
  280.  
  281.    case GL_TEXTURE_MAX_LEVEL:
  282.       if (texObj->MaxLevel == params[0])
  283.          return GL_FALSE;
  284.       if (params[0] < 0 || texObj->Target == GL_TEXTURE_RECTANGLE_ARB) {
  285.          _mesa_error(ctx, GL_INVALID_OPERATION,
  286.                      "glTexParameter(param=%d)", params[0]);
  287.          return GL_FALSE;
  288.       }
  289.       flush(ctx, texObj);
  290.       texObj->MaxLevel = params[0];
  291.       return GL_TRUE;
  292.  
  293.    case GL_GENERATE_MIPMAP_SGIS:
  294.       if (texObj->GenerateMipmap != params[0]) {
  295.          flush(ctx, texObj);
  296.          texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
  297.          return GL_TRUE;
  298.       }
  299.       return GL_FALSE;
  300.  
  301.    case GL_TEXTURE_COMPARE_MODE_ARB:
  302.       if (ctx->Extensions.ARB_shadow &&
  303.           (params[0] == GL_NONE ||
  304.            params[0] == GL_COMPARE_R_TO_TEXTURE_ARB)) {
  305.          if (texObj->CompareMode != params[0]) {
  306.             flush(ctx, texObj);
  307.             texObj->CompareMode = params[0];
  308.             return GL_TRUE;
  309.          }
  310.          return GL_FALSE;
  311.       }
  312.       else {
  313.          _mesa_error(ctx, GL_INVALID_ENUM,
  314.                      "glTexParameter(GL_TEXTURE_COMPARE_MODE_ARB)");
  315.       }
  316.       return GL_FALSE;
  317.  
  318.    case GL_TEXTURE_COMPARE_FUNC_ARB:
  319.       if (ctx->Extensions.ARB_shadow) {
  320.          if (texObj->CompareFunc == params[0])
  321.             return GL_FALSE;
  322.          switch (params[0]) {
  323.          case GL_LEQUAL:
  324.          case GL_GEQUAL:
  325.             flush(ctx, texObj);
  326.             texObj->CompareFunc = params[0];
  327.             return GL_TRUE;
  328.          case GL_EQUAL:
  329.          case GL_NOTEQUAL:
  330.          case GL_LESS:
  331.          case GL_GREATER:
  332.          case GL_ALWAYS:
  333.          case GL_NEVER:
  334.             if (ctx->Extensions.EXT_shadow_funcs) {
  335.                flush(ctx, texObj);
  336.                texObj->CompareFunc = params[0];
  337.                return GL_TRUE;
  338.             }
  339.             /* fall-through */
  340.          default:
  341.             _mesa_error(ctx, GL_INVALID_ENUM,
  342.                         "glTexParameter(GL_TEXTURE_COMPARE_FUNC_ARB)");
  343.          }
  344.       }
  345.       else {
  346.          _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
  347.       }
  348.       return GL_FALSE;
  349.  
  350.    case GL_DEPTH_TEXTURE_MODE_ARB:
  351.       if (ctx->Extensions.ARB_depth_texture &&
  352.           (params[0] == GL_LUMINANCE ||
  353.            params[0] == GL_INTENSITY ||
  354.            params[0] == GL_ALPHA ||
  355.            (ctx->Extensions.ARB_texture_rg && params[0] == GL_RED))) {
  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. #if 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(struct gl_context *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.          static GLuint count = 0;
  473.          if (count++ < 10)
  474.             _mesa_error(ctx, GL_INVALID_ENUM,
  475.                         "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
  476.       }
  477.       return GL_FALSE;
  478.  
  479.    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
  480.       if (ctx->Extensions.ARB_shadow_ambient) {
  481.          if (texObj->CompareFailValue != params[0]) {
  482.             flush(ctx, texObj);
  483.             texObj->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
  484.             return GL_TRUE;
  485.          }
  486.       }
  487.       else {
  488.          _mesa_error(ctx, GL_INVALID_ENUM,
  489.                     "glTexParameter(pname=GL_TEXTURE_COMPARE_FAIL_VALUE_ARB)");
  490.       }
  491.       return GL_FALSE;
  492.  
  493.    case GL_TEXTURE_LOD_BIAS:
  494.       /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
  495.       if (ctx->Extensions.EXT_texture_lod_bias) {
  496.          if (texObj->LodBias != params[0]) {
  497.             flush(ctx, texObj);
  498.             texObj->LodBias = params[0];
  499.             return GL_TRUE;
  500.          }
  501.          return GL_FALSE;
  502.       }
  503.       break;
  504.  
  505.    case GL_TEXTURE_BORDER_COLOR:
  506.       flush(ctx, texObj);
  507.       texObj->BorderColor.f[RCOMP] = params[0];
  508.       texObj->BorderColor.f[GCOMP] = params[1];
  509.       texObj->BorderColor.f[BCOMP] = params[2];
  510.       texObj->BorderColor.f[ACOMP] = params[3];
  511.       return GL_TRUE;
  512.  
  513.    default:
  514.       _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
  515.    }
  516.    return GL_FALSE;
  517. }
  518.  
  519.  
  520. void GLAPIENTRY
  521. _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param)
  522. {
  523.    GLboolean need_update;
  524.    struct gl_texture_object *texObj;
  525.    GET_CURRENT_CONTEXT(ctx);
  526.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  527.  
  528.    texObj = get_texobj(ctx, target, GL_FALSE);
  529.    if (!texObj)
  530.       return;
  531.  
  532.    switch (pname) {
  533.    case GL_TEXTURE_MIN_FILTER:
  534.    case GL_TEXTURE_MAG_FILTER:
  535.    case GL_TEXTURE_WRAP_S:
  536.    case GL_TEXTURE_WRAP_T:
  537.    case GL_TEXTURE_WRAP_R:
  538.    case GL_TEXTURE_BASE_LEVEL:
  539.    case GL_TEXTURE_MAX_LEVEL:
  540.    case GL_GENERATE_MIPMAP_SGIS:
  541.    case GL_TEXTURE_COMPARE_MODE_ARB:
  542.    case GL_TEXTURE_COMPARE_FUNC_ARB:
  543.    case GL_DEPTH_TEXTURE_MODE_ARB:
  544.       {
  545.          /* convert float param to int */
  546.          GLint p[4];
  547.          p[0] = (GLint) param;
  548.          p[1] = p[2] = p[3] = 0;
  549.          need_update = set_tex_parameteri(ctx, texObj, pname, p);
  550.       }
  551.       break;
  552.    default:
  553.       {
  554.          /* this will generate an error if pname is illegal */
  555.          GLfloat p[4];
  556.          p[0] = param;
  557.          p[1] = p[2] = p[3] = 0.0F;
  558.          need_update = set_tex_parameterf(ctx, texObj, pname, p);
  559.       }
  560.    }
  561.  
  562.    if (ctx->Driver.TexParameter && need_update) {
  563.       ctx->Driver.TexParameter(ctx, target, texObj, pname, &param);
  564.    }
  565. }
  566.  
  567.  
  568. void GLAPIENTRY
  569. _mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
  570. {
  571.    GLboolean need_update;
  572.    struct gl_texture_object *texObj;
  573.    GET_CURRENT_CONTEXT(ctx);
  574.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  575.  
  576.    texObj = get_texobj(ctx, target, GL_FALSE);
  577.    if (!texObj)
  578.       return;
  579.  
  580.    switch (pname) {
  581.    case GL_TEXTURE_MIN_FILTER:
  582.    case GL_TEXTURE_MAG_FILTER:
  583.    case GL_TEXTURE_WRAP_S:
  584.    case GL_TEXTURE_WRAP_T:
  585.    case GL_TEXTURE_WRAP_R:
  586.    case GL_TEXTURE_BASE_LEVEL:
  587.    case GL_TEXTURE_MAX_LEVEL:
  588.    case GL_GENERATE_MIPMAP_SGIS:
  589.    case GL_TEXTURE_COMPARE_MODE_ARB:
  590.    case GL_TEXTURE_COMPARE_FUNC_ARB:
  591.    case GL_DEPTH_TEXTURE_MODE_ARB:
  592.       {
  593.          /* convert float param to int */
  594.          GLint p[4];
  595.          p[0] = (GLint) params[0];
  596.          p[1] = p[2] = p[3] = 0;
  597.          need_update = set_tex_parameteri(ctx, texObj, pname, p);
  598.       }
  599.       break;
  600.  
  601. #if FEATURE_OES_draw_texture
  602.    case GL_TEXTURE_CROP_RECT_OES:
  603.       {
  604.          /* convert float params to int */
  605.          GLint iparams[4];
  606.          iparams[0] = (GLint) params[0];
  607.          iparams[1] = (GLint) params[1];
  608.          iparams[2] = (GLint) params[2];
  609.          iparams[3] = (GLint) params[3];
  610.          need_update = set_tex_parameteri(ctx, texObj, pname, iparams);
  611.       }
  612.       break;
  613. #endif
  614.  
  615.    default:
  616.       /* this will generate an error if pname is illegal */
  617.       need_update = set_tex_parameterf(ctx, texObj, pname, params);
  618.    }
  619.  
  620.    if (ctx->Driver.TexParameter && need_update) {
  621.       ctx->Driver.TexParameter(ctx, target, texObj, pname, params);
  622.    }
  623. }
  624.  
  625.  
  626. void GLAPIENTRY
  627. _mesa_TexParameteri(GLenum target, GLenum pname, GLint param)
  628. {
  629.    GLboolean need_update;
  630.    struct gl_texture_object *texObj;
  631.    GET_CURRENT_CONTEXT(ctx);
  632.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  633.  
  634.    texObj = get_texobj(ctx, target, GL_FALSE);
  635.    if (!texObj)
  636.       return;
  637.  
  638.    switch (pname) {
  639.    case GL_TEXTURE_MIN_LOD:
  640.    case GL_TEXTURE_MAX_LOD:
  641.    case GL_TEXTURE_PRIORITY:
  642.    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
  643.    case GL_TEXTURE_LOD_BIAS:
  644.    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
  645.       {
  646.          GLfloat fparam[4];
  647.          fparam[0] = (GLfloat) param;
  648.          fparam[1] = fparam[2] = fparam[3] = 0.0F;
  649.          /* convert int param to float */
  650.          need_update = set_tex_parameterf(ctx, texObj, pname, fparam);
  651.       }
  652.       break;
  653.    default:
  654.       /* this will generate an error if pname is illegal */
  655.       {
  656.          GLint iparam[4];
  657.          iparam[0] = param;
  658.          iparam[1] = iparam[2] = iparam[3] = 0;
  659.          need_update = set_tex_parameteri(ctx, texObj, pname, iparam);
  660.       }
  661.    }
  662.  
  663.    if (ctx->Driver.TexParameter && need_update) {
  664.       GLfloat fparam = (GLfloat) param;
  665.       ctx->Driver.TexParameter(ctx, target, texObj, pname, &fparam);
  666.    }
  667. }
  668.  
  669.  
  670. void GLAPIENTRY
  671. _mesa_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
  672. {
  673.    GLboolean need_update;
  674.    struct gl_texture_object *texObj;
  675.    GET_CURRENT_CONTEXT(ctx);
  676.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  677.  
  678.    texObj = get_texobj(ctx, target, GL_FALSE);
  679.    if (!texObj)
  680.       return;
  681.  
  682.    switch (pname) {
  683.    case GL_TEXTURE_BORDER_COLOR:
  684.       {
  685.          /* convert int params to float */
  686.          GLfloat fparams[4];
  687.          fparams[0] = INT_TO_FLOAT(params[0]);
  688.          fparams[1] = INT_TO_FLOAT(params[1]);
  689.          fparams[2] = INT_TO_FLOAT(params[2]);
  690.          fparams[3] = INT_TO_FLOAT(params[3]);
  691.          need_update = set_tex_parameterf(ctx, texObj, pname, fparams);
  692.       }
  693.       break;
  694.    case GL_TEXTURE_MIN_LOD:
  695.    case GL_TEXTURE_MAX_LOD:
  696.    case GL_TEXTURE_PRIORITY:
  697.    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
  698.    case GL_TEXTURE_LOD_BIAS:
  699.    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
  700.       {
  701.          /* convert int param to float */
  702.          GLfloat fparams[4];
  703.          fparams[0] = (GLfloat) params[0];
  704.          fparams[1] = fparams[2] = fparams[3] = 0.0F;
  705.          need_update = set_tex_parameterf(ctx, texObj, pname, fparams);
  706.       }
  707.       break;
  708.    default:
  709.       /* this will generate an error if pname is illegal */
  710.       need_update = set_tex_parameteri(ctx, texObj, pname, params);
  711.    }
  712.  
  713.    if (ctx->Driver.TexParameter && need_update) {
  714.       GLfloat fparams[4];
  715.       fparams[0] = INT_TO_FLOAT(params[0]);
  716.       if (pname == GL_TEXTURE_BORDER_COLOR ||
  717.           pname == GL_TEXTURE_CROP_RECT_OES) {
  718.          fparams[1] = INT_TO_FLOAT(params[1]);
  719.          fparams[2] = INT_TO_FLOAT(params[2]);
  720.          fparams[3] = INT_TO_FLOAT(params[3]);
  721.       }
  722.       ctx->Driver.TexParameter(ctx, target, texObj, pname, fparams);
  723.    }
  724. }
  725.  
  726.  
  727. /**
  728.  * Set tex parameter to integer value(s).  Primarily intended to set
  729.  * integer-valued texture border color (for integer-valued textures).
  730.  * New in GL 3.0.
  731.  */
  732. void GLAPIENTRY
  733. _mesa_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
  734. {
  735.    struct gl_texture_object *texObj;
  736.    GET_CURRENT_CONTEXT(ctx);
  737.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  738.  
  739.    texObj = get_texobj(ctx, target, GL_FALSE);
  740.    if (!texObj)
  741.       return;
  742.  
  743.    switch (pname) {
  744.    case GL_TEXTURE_BORDER_COLOR:
  745.       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  746.       /* set the integer-valued border color */
  747.       COPY_4V(texObj->BorderColor.i, params);
  748.       break;
  749.    default:
  750.       _mesa_TexParameteriv(target, pname, params);
  751.       break;
  752.    }
  753.    /* XXX no driver hook for TexParameterIiv() yet */
  754. }
  755.  
  756.  
  757. /**
  758.  * Set tex parameter to unsigned integer value(s).  Primarily intended to set
  759.  * uint-valued texture border color (for integer-valued textures).
  760.  * New in GL 3.0
  761.  */
  762. void GLAPIENTRY
  763. _mesa_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
  764. {
  765.    struct gl_texture_object *texObj;
  766.    GET_CURRENT_CONTEXT(ctx);
  767.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  768.  
  769.    texObj = get_texobj(ctx, target, GL_FALSE);
  770.    if (!texObj)
  771.       return;
  772.  
  773.    switch (pname) {
  774.    case GL_TEXTURE_BORDER_COLOR:
  775.       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  776.       /* set the unsigned integer-valued border color */
  777.       COPY_4V(texObj->BorderColor.ui, params);
  778.       break;
  779.    default:
  780.       _mesa_TexParameteriv(target, pname, (const GLint *) params);
  781.       break;
  782.    }
  783.    /* XXX no driver hook for TexParameterIuiv() yet */
  784. }
  785.  
  786.  
  787.  
  788.  
  789. void GLAPIENTRY
  790. _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
  791.                               GLenum pname, GLfloat *params )
  792. {
  793.    GLint iparam;
  794.    _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
  795.    *params = (GLfloat) iparam;
  796. }
  797.  
  798.  
  799. void GLAPIENTRY
  800. _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
  801.                               GLenum pname, GLint *params )
  802. {
  803.    const struct gl_texture_unit *texUnit;
  804.    struct gl_texture_object *texObj;
  805.    const struct gl_texture_image *img = NULL;
  806.    GLboolean isProxy;
  807.    GLint maxLevels;
  808.    gl_format texFormat;
  809.    GET_CURRENT_CONTEXT(ctx);
  810.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  811.  
  812.    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxCombinedTextureImageUnits) {
  813.       _mesa_error(ctx, GL_INVALID_OPERATION,
  814.                   "glGetTexLevelParameteriv(current unit)");
  815.       return;
  816.    }
  817.  
  818.    texUnit = _mesa_get_current_tex_unit(ctx);
  819.  
  820.    /* this will catch bad target values */
  821.    maxLevels = _mesa_max_texture_levels(ctx, target);
  822.    if (maxLevels == 0) {
  823.       _mesa_error(ctx, GL_INVALID_ENUM,
  824.                   "glGetTexLevelParameter[if]v(target=0x%x)", target);
  825.       return;
  826.    }
  827.  
  828.    if (level < 0 || level >= maxLevels) {
  829.       _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
  830.       return;
  831.    }
  832.  
  833.    texObj = _mesa_select_tex_object(ctx, texUnit, target);
  834.    _mesa_lock_texture(ctx, texObj);
  835.  
  836.    img = _mesa_select_tex_image(ctx, texObj, target, level);
  837.    if (!img || !img->TexFormat) {
  838.       /* undefined texture image */
  839.       if (pname == GL_TEXTURE_COMPONENTS)
  840.          *params = 1;
  841.       else
  842.          *params = 0;
  843.       goto out;
  844.    }
  845.  
  846.    texFormat = img->TexFormat;
  847.  
  848.    isProxy = _mesa_is_proxy_texture(target);
  849.  
  850.    switch (pname) {
  851.       case GL_TEXTURE_WIDTH:
  852.          *params = img->Width;
  853.          break;
  854.       case GL_TEXTURE_HEIGHT:
  855.          *params = img->Height;
  856.          break;
  857.       case GL_TEXTURE_DEPTH:
  858.          *params = img->Depth;
  859.          break;
  860.       case GL_TEXTURE_INTERNAL_FORMAT:
  861.          if (_mesa_is_format_compressed(img->TexFormat)) {
  862.             /* need to return the actual compressed format */
  863.             *params = _mesa_compressed_format_to_glenum(ctx, img->TexFormat);
  864.          }
  865.          else {
  866.             /* return the user's requested internal format */
  867.             *params = img->InternalFormat;
  868.          }
  869.          break;
  870.       case GL_TEXTURE_BORDER:
  871.          *params = img->Border;
  872.          break;
  873.       case GL_TEXTURE_RED_SIZE:
  874.          if (img->_BaseFormat == GL_RED) {
  875.             *params = _mesa_get_format_bits(texFormat, pname);
  876.             break;
  877.          }
  878.          /* FALLTHROUGH */
  879.       case GL_TEXTURE_GREEN_SIZE:
  880.          if (img->_BaseFormat == GL_RG) {
  881.             *params = _mesa_get_format_bits(texFormat, pname);
  882.             break;
  883.          }
  884.          /* FALLTHROUGH */
  885.       case GL_TEXTURE_BLUE_SIZE:
  886.          if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
  887.             *params = _mesa_get_format_bits(texFormat, pname);
  888.          else
  889.             *params = 0;
  890.          break;
  891.       case GL_TEXTURE_ALPHA_SIZE:
  892.          if (img->_BaseFormat == GL_ALPHA ||
  893.              img->_BaseFormat == GL_LUMINANCE_ALPHA ||
  894.              img->_BaseFormat == GL_RGBA)
  895.             *params = _mesa_get_format_bits(texFormat, pname);
  896.          else
  897.             *params = 0;
  898.          break;
  899.       case GL_TEXTURE_INTENSITY_SIZE:
  900.          if (img->_BaseFormat != GL_INTENSITY)
  901.             *params = 0;
  902.          else {
  903.             *params = _mesa_get_format_bits(texFormat, pname);
  904.             if (*params == 0) {
  905.                /* intensity probably stored as rgb texture */
  906.                *params = MIN2(_mesa_get_format_bits(texFormat, GL_TEXTURE_RED_SIZE),
  907.                               _mesa_get_format_bits(texFormat, GL_TEXTURE_GREEN_SIZE));
  908.             }
  909.          }
  910.          break;
  911.       case GL_TEXTURE_LUMINANCE_SIZE:
  912.          if (img->_BaseFormat != GL_LUMINANCE &&
  913.              img->_BaseFormat != GL_LUMINANCE_ALPHA)
  914.             *params = 0;
  915.          else {
  916.             *params = _mesa_get_format_bits(texFormat, pname);
  917.             if (*params == 0) {
  918.                /* luminance probably stored as rgb texture */
  919.                *params = MIN2(_mesa_get_format_bits(texFormat, GL_TEXTURE_RED_SIZE),
  920.                               _mesa_get_format_bits(texFormat, GL_TEXTURE_GREEN_SIZE));
  921.             }
  922.          }
  923.          break;
  924.       case GL_TEXTURE_INDEX_SIZE_EXT:
  925.          if (img->_BaseFormat == GL_COLOR_INDEX)
  926.             *params = _mesa_get_format_bits(texFormat, pname);
  927.          else
  928.             *params = 0;
  929.          break;
  930.       case GL_TEXTURE_DEPTH_SIZE_ARB:
  931.          if (ctx->Extensions.ARB_depth_texture)
  932.             *params = _mesa_get_format_bits(texFormat, pname);
  933.          else
  934.             _mesa_error(ctx, GL_INVALID_ENUM,
  935.                         "glGetTexLevelParameter[if]v(pname)");
  936.          break;
  937.       case GL_TEXTURE_STENCIL_SIZE_EXT:
  938.          if (ctx->Extensions.EXT_packed_depth_stencil ||
  939.              ctx->Extensions.ARB_framebuffer_object) {
  940.             *params = _mesa_get_format_bits(texFormat, pname);
  941.          }
  942.          else {
  943.             _mesa_error(ctx, GL_INVALID_ENUM,
  944.                         "glGetTexLevelParameter[if]v(pname)");
  945.          }
  946.          break;
  947.       case GL_TEXTURE_SHARED_SIZE:
  948.          if (ctx->VersionMajor >= 3) {
  949.             /* XXX return number of exponent bits for shared exponent texture
  950.              * formats, like GL_RGB9_E5.
  951.              */
  952.             *params = 0;
  953.          }
  954.          else {
  955.             _mesa_error(ctx, GL_INVALID_ENUM,
  956.                         "glGetTexLevelParameter[if]v(pname)");
  957.          }
  958.          break;
  959.  
  960.       /* GL_ARB_texture_compression */
  961.       case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
  962.          if (_mesa_is_format_compressed(img->TexFormat) && !isProxy) {
  963.             *params = _mesa_format_image_size(texFormat, img->Width,
  964.                                               img->Height, img->Depth);
  965.          }
  966.          else {
  967.             _mesa_error(ctx, GL_INVALID_OPERATION,
  968.                         "glGetTexLevelParameter[if]v(pname)");
  969.          }
  970.          break;
  971.       case GL_TEXTURE_COMPRESSED:
  972.          *params = (GLint) _mesa_is_format_compressed(img->TexFormat);
  973.          break;
  974.  
  975.       /* GL_ARB_texture_float */
  976.       case GL_TEXTURE_RED_TYPE_ARB:
  977.          if (ctx->Extensions.ARB_texture_float) {
  978.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_RED_SIZE) ?
  979.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  980.          }
  981.          else {
  982.             _mesa_error(ctx, GL_INVALID_ENUM,
  983.                         "glGetTexLevelParameter[if]v(pname)");
  984.          }
  985.          break;
  986.       case GL_TEXTURE_GREEN_TYPE_ARB:
  987.          if (ctx->Extensions.ARB_texture_float) {
  988.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_GREEN_SIZE) ?
  989.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  990.          }
  991.          else {
  992.             _mesa_error(ctx, GL_INVALID_ENUM,
  993.                         "glGetTexLevelParameter[if]v(pname)");
  994.          }
  995.          break;
  996.       case GL_TEXTURE_BLUE_TYPE_ARB:
  997.          if (ctx->Extensions.ARB_texture_float) {
  998.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_BLUE_SIZE) ?
  999.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  1000.          }
  1001.          else {
  1002.             _mesa_error(ctx, GL_INVALID_ENUM,
  1003.                         "glGetTexLevelParameter[if]v(pname)");
  1004.          }
  1005.          break;
  1006.       case GL_TEXTURE_ALPHA_TYPE_ARB:
  1007.          if (ctx->Extensions.ARB_texture_float) {
  1008.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_ALPHA_SIZE) ?
  1009.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  1010.          }
  1011.          else {
  1012.             _mesa_error(ctx, GL_INVALID_ENUM,
  1013.                         "glGetTexLevelParameter[if]v(pname)");
  1014.          }
  1015.          break;
  1016.       case GL_TEXTURE_LUMINANCE_TYPE_ARB:
  1017.          if (ctx->Extensions.ARB_texture_float) {
  1018.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_LUMINANCE_SIZE) ?
  1019.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  1020.          }
  1021.          else {
  1022.             _mesa_error(ctx, GL_INVALID_ENUM,
  1023.                         "glGetTexLevelParameter[if]v(pname)");
  1024.          }
  1025.          break;
  1026.       case GL_TEXTURE_INTENSITY_TYPE_ARB:
  1027.          if (ctx->Extensions.ARB_texture_float) {
  1028.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_INTENSITY_SIZE) ?
  1029.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  1030.          }
  1031.          else {
  1032.             _mesa_error(ctx, GL_INVALID_ENUM,
  1033.                         "glGetTexLevelParameter[if]v(pname)");
  1034.          }
  1035.          break;
  1036.       case GL_TEXTURE_DEPTH_TYPE_ARB:
  1037.          if (ctx->Extensions.ARB_texture_float) {
  1038.             *params = _mesa_get_format_bits(texFormat, GL_TEXTURE_DEPTH_SIZE) ?
  1039.                _mesa_get_format_datatype(texFormat) : GL_NONE;
  1040.          }
  1041.          else {
  1042.             _mesa_error(ctx, GL_INVALID_ENUM,
  1043.                         "glGetTexLevelParameter[if]v(pname)");
  1044.          }
  1045.          break;
  1046.  
  1047.       default:
  1048.          _mesa_error(ctx, GL_INVALID_ENUM,
  1049.                      "glGetTexLevelParameter[if]v(pname)");
  1050.    }
  1051.  
  1052.  out:
  1053.    _mesa_unlock_texture(ctx, texObj);
  1054. }
  1055.  
  1056.  
  1057.  
  1058. void GLAPIENTRY
  1059. _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
  1060. {
  1061.    struct gl_texture_object *obj;
  1062.    GLboolean error = GL_FALSE;
  1063.    GET_CURRENT_CONTEXT(ctx);
  1064.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1065.  
  1066.    obj = get_texobj(ctx, target, GL_TRUE);
  1067.    if (!obj)
  1068.       return;
  1069.  
  1070.    _mesa_lock_texture(ctx, obj);
  1071.    switch (pname) {
  1072.       case GL_TEXTURE_MAG_FILTER:
  1073.          *params = ENUM_TO_FLOAT(obj->MagFilter);
  1074.          break;
  1075.       case GL_TEXTURE_MIN_FILTER:
  1076.          *params = ENUM_TO_FLOAT(obj->MinFilter);
  1077.          break;
  1078.       case GL_TEXTURE_WRAP_S:
  1079.          *params = ENUM_TO_FLOAT(obj->WrapS);
  1080.          break;
  1081.       case GL_TEXTURE_WRAP_T:
  1082.          *params = ENUM_TO_FLOAT(obj->WrapT);
  1083.          break;
  1084.       case GL_TEXTURE_WRAP_R:
  1085.          *params = ENUM_TO_FLOAT(obj->WrapR);
  1086.          break;
  1087.       case GL_TEXTURE_BORDER_COLOR:
  1088.          params[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
  1089.          params[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
  1090.          params[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
  1091.          params[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
  1092.          break;
  1093.       case GL_TEXTURE_RESIDENT:
  1094.          {
  1095.             GLboolean resident;
  1096.             if (ctx->Driver.IsTextureResident)
  1097.                resident = ctx->Driver.IsTextureResident(ctx, obj);
  1098.             else
  1099.                resident = GL_TRUE;
  1100.             *params = ENUM_TO_FLOAT(resident);
  1101.          }
  1102.          break;
  1103.       case GL_TEXTURE_PRIORITY:
  1104.          *params = obj->Priority;
  1105.          break;
  1106.       case GL_TEXTURE_MIN_LOD:
  1107.          *params = obj->MinLod;
  1108.          break;
  1109.       case GL_TEXTURE_MAX_LOD:
  1110.          *params = obj->MaxLod;
  1111.          break;
  1112.       case GL_TEXTURE_BASE_LEVEL:
  1113.          *params = (GLfloat) obj->BaseLevel;
  1114.          break;
  1115.       case GL_TEXTURE_MAX_LEVEL:
  1116.          *params = (GLfloat) obj->MaxLevel;
  1117.          break;
  1118.       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
  1119.          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
  1120.             *params = obj->MaxAnisotropy;
  1121.          }
  1122.          else
  1123.             error = GL_TRUE;
  1124.          break;
  1125.       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
  1126.          if (ctx->Extensions.ARB_shadow_ambient) {
  1127.             *params = obj->CompareFailValue;
  1128.          }
  1129.          else
  1130.             error = GL_TRUE;
  1131.          break;
  1132.       case GL_GENERATE_MIPMAP_SGIS:
  1133.          *params = (GLfloat) obj->GenerateMipmap;
  1134.          break;
  1135.       case GL_TEXTURE_COMPARE_MODE_ARB:
  1136.          if (ctx->Extensions.ARB_shadow) {
  1137.             *params = (GLfloat) obj->CompareMode;
  1138.          }
  1139.          else
  1140.             error = GL_TRUE;
  1141.          break;
  1142.       case GL_TEXTURE_COMPARE_FUNC_ARB:
  1143.          if (ctx->Extensions.ARB_shadow) {
  1144.             *params = (GLfloat) obj->CompareFunc;
  1145.          }
  1146.          else
  1147.             error = GL_TRUE;
  1148.          break;
  1149.       case GL_DEPTH_TEXTURE_MODE_ARB:
  1150.          if (ctx->Extensions.ARB_depth_texture) {
  1151.             *params = (GLfloat) obj->DepthMode;
  1152.          }
  1153.          else
  1154.             error = GL_TRUE;
  1155.          break;
  1156.       case GL_TEXTURE_LOD_BIAS:
  1157.          if (ctx->Extensions.EXT_texture_lod_bias) {
  1158.             *params = obj->LodBias;
  1159.          }
  1160.          else
  1161.             error = GL_TRUE;
  1162.          break;
  1163. #if FEATURE_OES_draw_texture
  1164.       case GL_TEXTURE_CROP_RECT_OES:
  1165.          params[0] = obj->CropRect[0];
  1166.          params[1] = obj->CropRect[1];
  1167.          params[2] = obj->CropRect[2];
  1168.          params[3] = obj->CropRect[3];
  1169.          break;
  1170. #endif
  1171.  
  1172.       case GL_TEXTURE_SWIZZLE_R_EXT:
  1173.       case GL_TEXTURE_SWIZZLE_G_EXT:
  1174.       case GL_TEXTURE_SWIZZLE_B_EXT:
  1175.       case GL_TEXTURE_SWIZZLE_A_EXT:
  1176.          if (ctx->Extensions.EXT_texture_swizzle) {
  1177.             GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
  1178.             *params = (GLfloat) obj->Swizzle[comp];
  1179.          }
  1180.          else {
  1181.             error = GL_TRUE;
  1182.          }
  1183.          break;
  1184.  
  1185.       case GL_TEXTURE_SWIZZLE_RGBA_EXT:
  1186.          if (ctx->Extensions.EXT_texture_swizzle) {
  1187.             GLuint comp;
  1188.             for (comp = 0; comp < 4; comp++) {
  1189.                params[comp] = (GLfloat) obj->Swizzle[comp];
  1190.             }
  1191.          }
  1192.          else {
  1193.             error = GL_TRUE;
  1194.          }
  1195.          break;
  1196.  
  1197.       default:
  1198.          error = GL_TRUE;
  1199.          break;
  1200.    }
  1201.  
  1202.    if (error)
  1203.       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)",
  1204.                   pname);
  1205.  
  1206.    _mesa_unlock_texture(ctx, obj);
  1207. }
  1208.  
  1209.  
  1210. void GLAPIENTRY
  1211. _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  1212. {
  1213.    struct gl_texture_object *obj;
  1214.    GLboolean error = GL_FALSE;
  1215.    GET_CURRENT_CONTEXT(ctx);
  1216.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1217.  
  1218.     obj = get_texobj(ctx, target, GL_TRUE);
  1219.     if (!obj)
  1220.        return;
  1221.  
  1222.    _mesa_lock_texture(ctx, obj);
  1223.    switch (pname) {
  1224.       case GL_TEXTURE_MAG_FILTER:
  1225.          *params = (GLint) obj->MagFilter;
  1226.          break;;
  1227.       case GL_TEXTURE_MIN_FILTER:
  1228.          *params = (GLint) obj->MinFilter;
  1229.          break;;
  1230.       case GL_TEXTURE_WRAP_S:
  1231.          *params = (GLint) obj->WrapS;
  1232.          break;;
  1233.       case GL_TEXTURE_WRAP_T:
  1234.          *params = (GLint) obj->WrapT;
  1235.          break;;
  1236.       case GL_TEXTURE_WRAP_R:
  1237.          *params = (GLint) obj->WrapR;
  1238.          break;;
  1239.       case GL_TEXTURE_BORDER_COLOR:
  1240.          {
  1241.             GLfloat b[4];
  1242.             b[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
  1243.             b[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
  1244.             b[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
  1245.             b[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
  1246.             params[0] = FLOAT_TO_INT(b[0]);
  1247.             params[1] = FLOAT_TO_INT(b[1]);
  1248.             params[2] = FLOAT_TO_INT(b[2]);
  1249.             params[3] = FLOAT_TO_INT(b[3]);
  1250.          }
  1251.          break;;
  1252.       case GL_TEXTURE_RESIDENT:
  1253.          {
  1254.             GLboolean resident;
  1255.             if (ctx->Driver.IsTextureResident)
  1256.                resident = ctx->Driver.IsTextureResident(ctx, obj);
  1257.             else
  1258.                resident = GL_TRUE;
  1259.             *params = (GLint) resident;
  1260.          }
  1261.          break;;
  1262.       case GL_TEXTURE_PRIORITY:
  1263.          *params = FLOAT_TO_INT(obj->Priority);
  1264.          break;;
  1265.       case GL_TEXTURE_MIN_LOD:
  1266.          *params = (GLint) obj->MinLod;
  1267.          break;;
  1268.       case GL_TEXTURE_MAX_LOD:
  1269.          *params = (GLint) obj->MaxLod;
  1270.          break;;
  1271.       case GL_TEXTURE_BASE_LEVEL:
  1272.          *params = obj->BaseLevel;
  1273.          break;;
  1274.       case GL_TEXTURE_MAX_LEVEL:
  1275.          *params = obj->MaxLevel;
  1276.          break;;
  1277.       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
  1278.          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
  1279.             *params = (GLint) obj->MaxAnisotropy;
  1280.          }
  1281.          else {
  1282.             error = GL_TRUE;
  1283.          }
  1284.          break;
  1285.       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
  1286.          if (ctx->Extensions.ARB_shadow_ambient) {
  1287.             *params = (GLint) FLOAT_TO_INT(obj->CompareFailValue);
  1288.          }
  1289.          else {
  1290.             error = GL_TRUE;
  1291.          }
  1292.          break;
  1293.       case GL_GENERATE_MIPMAP_SGIS:
  1294.          *params = (GLint) obj->GenerateMipmap;
  1295.          break;
  1296.       case GL_TEXTURE_COMPARE_MODE_ARB:
  1297.          if (ctx->Extensions.ARB_shadow) {
  1298.             *params = (GLint) obj->CompareMode;
  1299.          }
  1300.          else {
  1301.             error = GL_TRUE;
  1302.          }
  1303.          break;
  1304.       case GL_TEXTURE_COMPARE_FUNC_ARB:
  1305.          if (ctx->Extensions.ARB_shadow) {
  1306.             *params = (GLint) obj->CompareFunc;
  1307.          }
  1308.          else {
  1309.             error = GL_TRUE;
  1310.          }
  1311.          break;
  1312.       case GL_DEPTH_TEXTURE_MODE_ARB:
  1313.          if (ctx->Extensions.ARB_depth_texture) {
  1314.             *params = (GLint) obj->DepthMode;
  1315.          }
  1316.          else {
  1317.             error = GL_TRUE;
  1318.          }
  1319.          break;
  1320.       case GL_TEXTURE_LOD_BIAS:
  1321.          if (ctx->Extensions.EXT_texture_lod_bias) {
  1322.             *params = (GLint) obj->LodBias;
  1323.          }
  1324.          else {
  1325.             error = GL_TRUE;
  1326.          }
  1327.          break;
  1328. #if FEATURE_OES_draw_texture
  1329.       case GL_TEXTURE_CROP_RECT_OES:
  1330.          params[0] = obj->CropRect[0];
  1331.          params[1] = obj->CropRect[1];
  1332.          params[2] = obj->CropRect[2];
  1333.          params[3] = obj->CropRect[3];
  1334.          break;
  1335. #endif
  1336.       case GL_TEXTURE_SWIZZLE_R_EXT:
  1337.       case GL_TEXTURE_SWIZZLE_G_EXT:
  1338.       case GL_TEXTURE_SWIZZLE_B_EXT:
  1339.       case GL_TEXTURE_SWIZZLE_A_EXT:
  1340.          if (ctx->Extensions.EXT_texture_swizzle) {
  1341.             GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
  1342.             *params = obj->Swizzle[comp];
  1343.          }
  1344.          else {
  1345.             error = GL_TRUE;
  1346.          }
  1347.          break;
  1348.  
  1349.       case GL_TEXTURE_SWIZZLE_RGBA_EXT:
  1350.          if (ctx->Extensions.EXT_texture_swizzle) {
  1351.             COPY_4V(params, obj->Swizzle);
  1352.          }
  1353.          else {
  1354.             error = GL_TRUE;
  1355.          }
  1356.          break;
  1357.  
  1358.       default:
  1359.          ; /* silence warnings */
  1360.    }
  1361.  
  1362.    if (error)
  1363.       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)",
  1364.                   pname);
  1365.  
  1366.    _mesa_unlock_texture(ctx, obj);
  1367. }
  1368.  
  1369.  
  1370. /** New in GL 3.0 */
  1371. void GLAPIENTRY
  1372. _mesa_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
  1373. {
  1374.    struct gl_texture_object *texObj;
  1375.    GET_CURRENT_CONTEXT(ctx);
  1376.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1377.  
  1378.    texObj = get_texobj(ctx, target, GL_TRUE);
  1379.    
  1380.    switch (pname) {
  1381.    case GL_TEXTURE_BORDER_COLOR:
  1382.       COPY_4V(params, texObj->BorderColor.i);
  1383.       break;
  1384.    default:
  1385.       _mesa_GetTexParameteriv(target, pname, params);
  1386.    }
  1387. }
  1388.  
  1389.  
  1390. /** New in GL 3.0 */
  1391. void GLAPIENTRY
  1392. _mesa_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
  1393. {
  1394.    struct gl_texture_object *texObj;
  1395.    GET_CURRENT_CONTEXT(ctx);
  1396.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1397.  
  1398.    texObj = get_texobj(ctx, target, GL_TRUE);
  1399.    
  1400.    switch (pname) {
  1401.    case GL_TEXTURE_BORDER_COLOR:
  1402.       COPY_4V(params, texObj->BorderColor.i);
  1403.       break;
  1404.    default:
  1405.       {
  1406.          GLint ip[4];
  1407.          _mesa_GetTexParameteriv(target, pname, ip);
  1408.          params[0] = ip[0];
  1409.          if (pname == GL_TEXTURE_SWIZZLE_RGBA_EXT ||
  1410.              pname == GL_TEXTURE_CROP_RECT_OES) {
  1411.             params[1] = ip[1];
  1412.             params[2] = ip[2];
  1413.             params[3] = ip[3];
  1414.          }
  1415.       }
  1416.    }
  1417. }
  1418.