src/mesa/main/texstate.c

   1 /* $Id: texstate.c,v 1.54 2001/06/18 17:26:08 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "colormac.h"
  33 #include "context.h"
  34 #include "enums.h"
  35 #include "extensions.h"
  36 #include "macros.h"
  37 #include "texobj.h"
  38 #include "teximage.h"
  39 #include "texstate.h"
  40 #include "mtypes.h"
  41 #include "math/m_xform.h"
  42 #include "math/m_matrix.h"
  43 #endif
  44
  45
  46
  47 #ifdef SPECIALCAST
  48 /* Needed for an Amiga compiler */
  49 #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
  50 #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
  51 #else
  52 /* all other compilers */
  53 #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
  54 #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
  55 #endif
  56
  57
  58
  59 /**********************************************************************/
  60 /*                       Texture Environment                          */
  61 /**********************************************************************/
  62
  63
  64 void
  65 _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
  66 {
  67    GET_CURRENT_CONTEXT(ctx);
  68    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  69    ASSERT_OUTSIDE_BEGIN_END(ctx);
  70
  71 #define ERROR(errCode, msg, value)                              \
  72    {                                                            \
  73       char s[100];                                              \
  74       sprintf(s, msg, _mesa_lookup_enum_by_nr(value));          \
  75       _mesa_error(ctx, errCode, s);                             \
  76    }
  77
  78    if (target==GL_TEXTURE_ENV) {
  79       switch (pname) {
  80       case GL_TEXTURE_ENV_MODE: {
  81          GLenum mode = (GLenum) (GLint) *param;
  82
  83          switch (mode) {
  84          case GL_ADD:
  85             if (!ctx->Extensions.EXT_texture_env_add) {
  86                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
  87                return;
  88             }
  89             break;
  90          case GL_COMBINE_EXT:
  91             if (!ctx->Extensions.EXT_texture_env_combine &&
  92                 !ctx->Extensions.ARB_texture_env_combine) {
  93                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
  94                return;
  95             }
  96             break;
  97          case GL_MODULATE:
  98          case GL_BLEND:
  99          case GL_DECAL:
 100          case GL_REPLACE:
 101             break;
 102          default:
 103             ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 104             return;
 105          }
 106
 107          if (texUnit->EnvMode == mode)
 108             return;
 109          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 110          texUnit->EnvMode = mode;
 111          break;
 112       }
 113       case GL_TEXTURE_ENV_COLOR: {
 114          GLfloat tmp[4];
 115          tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
 116          tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
 117          tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
 118          tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
 119          if (TEST_EQ_4V(tmp, texUnit->EnvColor))
 120             return;
 121          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 122          COPY_4FV(texUnit->EnvColor, tmp);
 123          break;
 124       }
 125       case GL_COMBINE_RGB_EXT:
 126          if (ctx->Extensions.EXT_texture_env_combine ||
 127              ctx->Extensions.ARB_texture_env_combine) {
 128             const GLenum mode = (GLenum) (GLint) *param;
 129             switch (mode) {
 130             case GL_REPLACE:
 131             case GL_MODULATE:
 132             case GL_ADD:
 133             case GL_ADD_SIGNED_EXT:
 134             case GL_INTERPOLATE_EXT:
 135                /* OK */
 136                break;
 137             case GL_SUBTRACT_ARB:
 138                if (!ctx->Extensions.ARB_texture_env_combine) {
 139                   ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 140                   return;
 141                }
 142                break;
 143             case GL_DOT3_RGB_EXT:
 144             case GL_DOT3_RGBA_EXT:
 145                if (!ctx->Extensions.EXT_texture_env_dot3) {
 146                   ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 147                   return;
 148                }
 149                break;
 150             case GL_DOT3_RGB_ARB:
 151             case GL_DOT3_RGBA_ARB:
 152                if (!ctx->Extensions.ARB_texture_env_dot3) {
 153                   ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 154                   return;
 155                }
 156                break;
 157             default:
 158                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 159                return;
 160             }
 161             if (texUnit->CombineModeRGB == mode)
 162                return;
 163             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 164             texUnit->CombineModeRGB = mode;
 165          }
 166          else {
 167             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 168             return;
 169          }
 170          break;
 171       case GL_COMBINE_ALPHA_EXT:
 172          if (ctx->Extensions.EXT_texture_env_combine ||
 173              ctx->Extensions.ARB_texture_env_combine) {
 174             const GLenum mode = (GLenum) (GLint) *param;
 175             switch (mode) {
 176             case GL_REPLACE:
 177             case GL_MODULATE:
 178             case GL_ADD:
 179             case GL_ADD_SIGNED_EXT:
 180             case GL_INTERPOLATE_EXT:
 181                /* OK */
 182                break;
 183             case GL_SUBTRACT_ARB:
 184                if (!ctx->Extensions.ARB_texture_env_combine) {
 185                   ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 186                   return;
 187                }
 188                break;
 189             default:
 190                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
 191                return;
 192             }
 193             if (texUnit->CombineModeA == mode)
 194                return;
 195             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 196             texUnit->CombineModeA = mode;
 197          }
 198          else {
 199             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 200             return;
 201          }
 202          break;
 203       case GL_SOURCE0_RGB_EXT:
 204       case GL_SOURCE1_RGB_EXT:
 205       case GL_SOURCE2_RGB_EXT:
 206          if (ctx->Extensions.EXT_texture_env_combine ||
 207              ctx->Extensions.ARB_texture_env_combine) {
 208             GLenum source = (GLenum) (GLint) *param;
 209             GLuint s = pname - GL_SOURCE0_RGB_EXT;
 210             switch (source) {
 211             case GL_TEXTURE:
 212             case GL_CONSTANT_EXT:
 213             case GL_PRIMARY_COLOR_EXT:
 214             case GL_PREVIOUS_EXT:
 215                if (texUnit->CombineSourceRGB[s] == source)
 216                   return;
 217                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 218                texUnit->CombineSourceRGB[s] = source;
 219                break;
 220             default:
 221                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
 222                return;
 223             }
 224          }
 225          else {
 226             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 227             return;
 228          }
 229          break;
 230       case GL_SOURCE0_ALPHA_EXT:
 231       case GL_SOURCE1_ALPHA_EXT:
 232       case GL_SOURCE2_ALPHA_EXT:
 233          if (ctx->Extensions.EXT_texture_env_combine ||
 234              ctx->Extensions.ARB_texture_env_combine) {
 235             GLenum source = (GLenum) (GLint) *param;
 236             GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
 237             switch (source) {
 238             case GL_TEXTURE:
 239             case GL_CONSTANT_EXT:
 240             case GL_PRIMARY_COLOR_EXT:
 241             case GL_PREVIOUS_EXT:
 242                if (texUnit->CombineSourceA[s] == source) return;
 243                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 244                texUnit->CombineSourceA[s] = source;
 245                break;
 246             default:
 247                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
 248                return;
 249             }
 250          }
 251          else {
 252             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 253             return;
 254          }
 255          break;
 256       case GL_OPERAND0_RGB_EXT:
 257       case GL_OPERAND1_RGB_EXT:
 258          if (ctx->Extensions.EXT_texture_env_combine ||
 259              ctx->Extensions.ARB_texture_env_combine) {
 260             GLenum operand = (GLenum) (GLint) *param;
 261             GLuint s = pname - GL_OPERAND0_RGB_EXT;
 262             switch (operand) {
 263             case GL_SRC_COLOR:
 264             case GL_ONE_MINUS_SRC_COLOR:
 265             case GL_SRC_ALPHA:
 266             case GL_ONE_MINUS_SRC_ALPHA:
 267                if (texUnit->CombineOperandRGB[s] == operand)
 268                   return;
 269                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 270                texUnit->CombineOperandRGB[s] = operand;
 271                break;
 272             default:
 273                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
 274                return;
 275             }
 276          }
 277          else {
 278             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 279             return;
 280          }
 281          break;
 282       case GL_OPERAND0_ALPHA_EXT:
 283       case GL_OPERAND1_ALPHA_EXT:
 284          if (ctx->Extensions.EXT_texture_env_combine ||
 285              ctx->Extensions.ARB_texture_env_combine) {
 286             GLenum operand = (GLenum) (GLint) *param;
 287             switch (operand) {
 288             case GL_SRC_ALPHA:
 289             case GL_ONE_MINUS_SRC_ALPHA:
 290                if (texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] ==
 291                    operand)
 292                   return;
 293                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 294                texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] = operand;
 295                break;
 296             default:
 297                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
 298                return;
 299             }
 300          }
 301          else {
 302             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 303             return;
 304          }
 305          break;
 306       case GL_OPERAND2_RGB_EXT:
 307          if (ctx->Extensions.EXT_texture_env_combine ||
 308              ctx->Extensions.ARB_texture_env_combine) {
 309             GLenum operand = (GLenum) (GLint) *param;
 310             switch (operand) {
 311             case GL_SRC_COLOR:           /* ARB combine only */
 312             case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
 313             case GL_SRC_ALPHA:
 314             case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
 315                if (texUnit->CombineOperandRGB[2] == operand)
 316                   return;
 317                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 318                texUnit->CombineOperandRGB[2] = operand;
 319             default:
 320                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
 321                return;
 322             }
 323          }
 324          else {
 325             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 326             return;
 327          }
 328          break;
 329       case GL_OPERAND2_ALPHA_EXT:
 330          if (ctx->Extensions.EXT_texture_env_combine ||
 331              ctx->Extensions.ARB_texture_env_combine) {
 332             GLenum operand = (GLenum) (GLint) *param;
 333             switch (operand) {
 334             case GL_SRC_ALPHA:
 335             case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
 336                if (texUnit->CombineOperandA[2] == operand)
 337                   return;
 338                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 339                texUnit->CombineOperandA[2] = operand;
 340                break;
 341             default:
 342                ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
 343                return;
 344             }
 345          }
 346          else {
 347             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 348             return;
 349          }
 350          break;
 351       case GL_RGB_SCALE_EXT:
 352          if (ctx->Extensions.EXT_texture_env_combine ||
 353              ctx->Extensions.ARB_texture_env_combine) {
 354             GLuint newshift;
 355             if (*param == 1.0) {
 356                newshift = 0;
 357             }
 358             else if (*param == 2.0) {
 359                newshift = 1;
 360             }
 361             else if (*param == 4.0) {
 362                newshift = 2;
 363             }
 364             else {
 365                _mesa_error( ctx, GL_INVALID_VALUE,
 366                             "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
 367                return;
 368             }
 369             if (texUnit->CombineScaleShiftRGB == newshift)
 370                return;
 371             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 372             texUnit->CombineScaleShiftRGB = newshift;
 373          }
 374          else {
 375             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 376             return;
 377          }
 378          break;
 379       case GL_ALPHA_SCALE:
 380          if (ctx->Extensions.EXT_texture_env_combine ||
 381              ctx->Extensions.ARB_texture_env_combine) {
 382             GLuint newshift;
 383             if (*param == 1.0) {
 384                newshift = 0;
 385             }
 386             else if (*param == 2.0) {
 387                newshift = 1;
 388             }
 389             else if (*param == 4.0) {
 390                newshift = 2;
 391             }
 392             else {
 393                _mesa_error( ctx, GL_INVALID_VALUE,
 394                             "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
 395                return;
 396             }
 397             if (texUnit->CombineScaleShiftA == newshift)
 398                return;
 399             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 400             texUnit->CombineScaleShiftA = newshift;
 401          }
 402          else {
 403             ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 404             return;
 405          }
 406          break;
 407       default:
 408          _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
 409          return;
 410       }
 411    }
 412    else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
 413       if (!ctx->Extensions.EXT_texture_lod_bias) {
 414          _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
 415          return;
 416       }
 417       switch (pname) {
 418       case GL_TEXTURE_LOD_BIAS_EXT:
 419          if (texUnit->LodBias == param[0])
 420             return;
 421          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 422          texUnit->LodBias = param[0];
 423          break;
 424       default:
 425          ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
 426          return;
 427       }
 428    }
 429    else {
 430       _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
 431       return;
 432    }
 433
 434    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
 435       fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
 436               _mesa_lookup_enum_by_nr(target),
 437               _mesa_lookup_enum_by_nr(pname),
 438               *param,
 439               _mesa_lookup_enum_by_nr((GLenum) (GLint) *param));
 440
 441    /* Tell device driver about the new texture environment */
 442    if (ctx->Driver.TexEnv) {
 443       (*ctx->Driver.TexEnv)( ctx, target, pname, param );
 444    }
 445 }
 446
 447
 448 void
 449 _mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
 450 {
 451    _mesa_TexEnvfv( target, pname, &param );
 452 }
 453
 454
 455
 456 void
 457 _mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
 458 {
 459    GLfloat p[4];
 460    p[0] = (GLfloat) param;
 461    p[1] = p[2] = p[3] = 0.0;
 462    _mesa_TexEnvfv( target, pname, p );
 463 }
 464
 465
 466 void
 467 _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
 468 {
 469    GLfloat p[4];
 470    p[0] = INT_TO_FLOAT( param[0] );
 471    p[1] = INT_TO_FLOAT( param[1] );
 472    p[2] = INT_TO_FLOAT( param[2] );
 473    p[3] = INT_TO_FLOAT( param[3] );
 474    _mesa_TexEnvfv( target, pname, p );
 475 }
 476
 477
 478 void
 479 _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
 480 {
 481    GET_CURRENT_CONTEXT(ctx);
 482    const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 483    ASSERT_OUTSIDE_BEGIN_END(ctx);
 484
 485    if (target!=GL_TEXTURE_ENV) {
 486       _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
 487       return;
 488    }
 489
 490    switch (pname) {
 491       case GL_TEXTURE_ENV_MODE:
 492          *params = ENUM_TO_FLOAT(texUnit->EnvMode);
 493          break;
 494       case GL_TEXTURE_ENV_COLOR:
 495          COPY_4FV( params, texUnit->EnvColor );
 496          break;
 497       case GL_COMBINE_RGB_EXT:
 498          if (ctx->Extensions.EXT_texture_env_combine ||
 499              ctx->Extensions.ARB_texture_env_combine) {
 500             *params = (GLfloat) texUnit->CombineModeRGB;
 501          }
 502          else {
 503             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 504          }
 505          break;
 506       case GL_COMBINE_ALPHA_EXT:
 507          if (ctx->Extensions.EXT_texture_env_combine ||
 508              ctx->Extensions.ARB_texture_env_combine) {
 509             *params = (GLfloat) texUnit->CombineModeA;
 510          }
 511          else {
 512             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 513          }
 514          break;
 515       case GL_SOURCE0_RGB_EXT:
 516          if (ctx->Extensions.EXT_texture_env_combine ||
 517              ctx->Extensions.ARB_texture_env_combine) {
 518             *params = (GLfloat) texUnit->CombineSourceRGB[0];
 519          }
 520          else {
 521             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 522          }
 523          break;
 524       case GL_SOURCE1_RGB_EXT:
 525          if (ctx->Extensions.EXT_texture_env_combine ||
 526              ctx->Extensions.ARB_texture_env_combine) {
 527             *params = (GLfloat) texUnit->CombineSourceRGB[1];
 528          }
 529          else {
 530             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 531          }
 532          break;
 533       case GL_SOURCE2_RGB_EXT:
 534          if (ctx->Extensions.EXT_texture_env_combine ||
 535              ctx->Extensions.ARB_texture_env_combine) {
 536             *params = (GLfloat) texUnit->CombineSourceRGB[2];
 537          }
 538          else {
 539             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 540          }
 541          break;
 542       case GL_SOURCE0_ALPHA_EXT:
 543          if (ctx->Extensions.EXT_texture_env_combine ||
 544              ctx->Extensions.ARB_texture_env_combine) {
 545             *params = (GLfloat) texUnit->CombineSourceA[0];
 546          }
 547          else {
 548             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 549          }
 550          break;
 551       case GL_SOURCE1_ALPHA_EXT:
 552          if (ctx->Extensions.EXT_texture_env_combine ||
 553              ctx->Extensions.ARB_texture_env_combine) {
 554             *params = (GLfloat) texUnit->CombineSourceA[1];
 555          }
 556          else {
 557             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 558          }
 559          break;
 560       case GL_SOURCE2_ALPHA_EXT:
 561          if (ctx->Extensions.EXT_texture_env_combine ||
 562              ctx->Extensions.ARB_texture_env_combine) {
 563             *params = (GLfloat) texUnit->CombineSourceA[2];
 564          }
 565          else {
 566             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 567          }
 568          break;
 569       case GL_OPERAND0_RGB_EXT:
 570          if (ctx->Extensions.EXT_texture_env_combine ||
 571              ctx->Extensions.ARB_texture_env_combine) {
 572             *params = (GLfloat) texUnit->CombineOperandRGB[0];
 573          }
 574          else {
 575             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 576          }
 577          break;
 578       case GL_OPERAND1_RGB_EXT:
 579          if (ctx->Extensions.EXT_texture_env_combine ||
 580              ctx->Extensions.ARB_texture_env_combine) {
 581             *params = (GLfloat) texUnit->CombineOperandRGB[1];
 582          }
 583          else {
 584             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 585          }
 586          break;
 587       case GL_OPERAND2_RGB_EXT:
 588          if (ctx->Extensions.EXT_texture_env_combine ||
 589              ctx->Extensions.ARB_texture_env_combine) {
 590             *params = (GLfloat) texUnit->CombineOperandRGB[2];
 591          }
 592          else {
 593             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 594          }
 595          break;
 596       case GL_OPERAND0_ALPHA_EXT:
 597          if (ctx->Extensions.EXT_texture_env_combine ||
 598              ctx->Extensions.ARB_texture_env_combine) {
 599             *params = (GLfloat) texUnit->CombineOperandA[0];
 600          }
 601          else {
 602             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 603          }
 604          break;
 605       case GL_OPERAND1_ALPHA_EXT:
 606          if (ctx->Extensions.EXT_texture_env_combine ||
 607              ctx->Extensions.ARB_texture_env_combine) {
 608             *params = (GLfloat) texUnit->CombineOperandA[1];
 609          }
 610          else {
 611             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 612          }
 613          break;
 614       case GL_OPERAND2_ALPHA_EXT:
 615          if (ctx->Extensions.EXT_texture_env_combine ||
 616              ctx->Extensions.ARB_texture_env_combine) {
 617             *params = (GLfloat) texUnit->CombineOperandA[2];
 618          }
 619          else {
 620             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 621          }
 622          break;
 623       case GL_RGB_SCALE_EXT:
 624          if (ctx->Extensions.EXT_texture_env_combine ||
 625              ctx->Extensions.ARB_texture_env_combine) {
 626             if (texUnit->CombineScaleShiftRGB == 0)
 627                *params = 1.0;
 628             else if (texUnit->CombineScaleShiftRGB == 1)
 629                *params = 2.0;
 630             else
 631                *params = 4.0;
 632          }
 633          else {
 634             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 635             return;
 636          }
 637          break;
 638       case GL_ALPHA_SCALE:
 639          if (ctx->Extensions.EXT_texture_env_combine ||
 640              ctx->Extensions.ARB_texture_env_combine) {
 641             if (texUnit->CombineScaleShiftA == 0)
 642                *params = 1.0;
 643             else if (texUnit->CombineScaleShiftA == 1)
 644                *params = 2.0;
 645             else
 646                *params = 4.0;
 647          }
 648          else {
 649             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
 650             return;
 651          }
 652          break;
 653       default:
 654          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
 655    }
 656 }
 657
 658
 659 void
 660 _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
 661 {
 662    GET_CURRENT_CONTEXT(ctx);
 663    const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 664    ASSERT_OUTSIDE_BEGIN_END(ctx);
 665
 666    if (target != GL_TEXTURE_ENV) {
 667       _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
 668       return;
 669    }
 670
 671    switch (pname) {
 672       case GL_TEXTURE_ENV_MODE:
 673          *params = (GLint) texUnit->EnvMode;
 674          break;
 675       case GL_TEXTURE_ENV_COLOR:
 676          params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
 677          params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
 678          params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
 679          params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
 680          break;
 681       case GL_COMBINE_RGB_EXT:
 682          if (ctx->Extensions.EXT_texture_env_combine ||
 683              ctx->Extensions.ARB_texture_env_combine) {
 684             *params = (GLint) texUnit->CombineModeRGB;
 685          }
 686          else {
 687             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 688          }
 689          break;
 690       case GL_COMBINE_ALPHA_EXT:
 691          if (ctx->Extensions.EXT_texture_env_combine ||
 692              ctx->Extensions.ARB_texture_env_combine) {
 693             *params = (GLint) texUnit->CombineModeA;
 694          }
 695          else {
 696             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 697          }
 698          break;
 699       case GL_SOURCE0_RGB_EXT:
 700          if (ctx->Extensions.EXT_texture_env_combine ||
 701              ctx->Extensions.ARB_texture_env_combine) {
 702             *params = (GLint) texUnit->CombineSourceRGB[0];
 703          }
 704          else {
 705             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 706          }
 707          break;
 708       case GL_SOURCE1_RGB_EXT:
 709          if (ctx->Extensions.EXT_texture_env_combine ||
 710              ctx->Extensions.ARB_texture_env_combine) {
 711             *params = (GLint) texUnit->CombineSourceRGB[1];
 712          }
 713          else {
 714             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 715          }
 716          break;
 717       case GL_SOURCE2_RGB_EXT:
 718          if (ctx->Extensions.EXT_texture_env_combine ||
 719              ctx->Extensions.ARB_texture_env_combine) {
 720             *params = (GLint) texUnit->CombineSourceRGB[2];
 721          }
 722          else {
 723             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 724          }
 725          break;
 726       case GL_SOURCE0_ALPHA_EXT:
 727          if (ctx->Extensions.EXT_texture_env_combine ||
 728              ctx->Extensions.ARB_texture_env_combine) {
 729             *params = (GLint) texUnit->CombineSourceA[0];
 730          }
 731          else {
 732             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 733          }
 734          break;
 735       case GL_SOURCE1_ALPHA_EXT:
 736          if (ctx->Extensions.EXT_texture_env_combine ||
 737              ctx->Extensions.ARB_texture_env_combine) {
 738             *params = (GLint) texUnit->CombineSourceA[1];
 739          }
 740          else {
 741             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 742          }
 743          break;
 744       case GL_SOURCE2_ALPHA_EXT:
 745          if (ctx->Extensions.EXT_texture_env_combine ||
 746              ctx->Extensions.ARB_texture_env_combine) {
 747             *params = (GLint) texUnit->CombineSourceA[2];
 748          }
 749          else {
 750             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 751          }
 752          break;
 753       case GL_OPERAND0_RGB_EXT:
 754          if (ctx->Extensions.EXT_texture_env_combine ||
 755              ctx->Extensions.ARB_texture_env_combine) {
 756             *params = (GLint) texUnit->CombineOperandRGB[0];
 757          }
 758          else {
 759             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 760          }
 761          break;
 762       case GL_OPERAND1_RGB_EXT:
 763          if (ctx->Extensions.EXT_texture_env_combine ||
 764              ctx->Extensions.ARB_texture_env_combine) {
 765             *params = (GLint) texUnit->CombineOperandRGB[1];
 766          }
 767          else {
 768             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 769          }
 770          break;
 771       case GL_OPERAND2_RGB_EXT:
 772          if (ctx->Extensions.EXT_texture_env_combine ||
 773              ctx->Extensions.ARB_texture_env_combine) {
 774             *params = (GLint) texUnit->CombineOperandRGB[2];
 775          }
 776          else {
 777             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 778          }
 779          break;
 780       case GL_OPERAND0_ALPHA_EXT:
 781          if (ctx->Extensions.EXT_texture_env_combine ||
 782              ctx->Extensions.ARB_texture_env_combine) {
 783             *params = (GLint) texUnit->CombineOperandA[0];
 784          }
 785          else {
 786             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 787          }
 788          break;
 789       case GL_OPERAND1_ALPHA_EXT:
 790          if (ctx->Extensions.EXT_texture_env_combine ||
 791              ctx->Extensions.ARB_texture_env_combine) {
 792             *params = (GLint) texUnit->CombineOperandA[1];
 793          }
 794          else {
 795             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 796          }
 797          break;
 798       case GL_OPERAND2_ALPHA_EXT:
 799          if (ctx->Extensions.EXT_texture_env_combine ||
 800              ctx->Extensions.ARB_texture_env_combine) {
 801             *params = (GLint) texUnit->CombineOperandA[2];
 802          }
 803          else {
 804             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 805          }
 806          break;
 807       case GL_RGB_SCALE_EXT:
 808          if (ctx->Extensions.EXT_texture_env_combine ||
 809              ctx->Extensions.ARB_texture_env_combine) {
 810             if (texUnit->CombineScaleShiftRGB == 0)
 811                *params = 1;
 812             else if (texUnit->CombineScaleShiftRGB == 1)
 813                *params = 2;
 814             else
 815                *params = 4;
 816          }
 817          else {
 818             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 819             return;
 820          }
 821          break;
 822       case GL_ALPHA_SCALE:
 823          if (ctx->Extensions.EXT_texture_env_combine ||
 824              ctx->Extensions.ARB_texture_env_combine) {
 825             if (texUnit->CombineScaleShiftA == 0)
 826                *params = 1;
 827             else if (texUnit->CombineScaleShiftA == 1)
 828                *params = 2;
 829             else
 830                *params = 4;
 831          }
 832          else {
 833             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
 834             return;
 835          }
 836          break;
 837       default:
 838          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
 839    }
 840 }
 841
 842
 843
 844
 845 /**********************************************************************/
 846 /*                       Texture Parameters                           */
 847 /**********************************************************************/
 848
 849
 850 void
 851 _mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
 852 {
 853    _mesa_TexParameterfv(target, pname, &param);
 854 }
 855
 856
 857 void
 858 _mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
 859 {
 860    GET_CURRENT_CONTEXT(ctx);
 861    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 862    GLenum eparam = (GLenum) (GLint) params[0];
 863    struct gl_texture_object *texObj;
 864    ASSERT_OUTSIDE_BEGIN_END(ctx);
 865
 866    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
 867       fprintf(stderr, "texPARAM %s %s %d...\n",
 868               _mesa_lookup_enum_by_nr(target),
 869               _mesa_lookup_enum_by_nr(pname),
 870               eparam);
 871
 872
 873    switch (target) {
 874       case GL_TEXTURE_1D:
 875          texObj = texUnit->Current1D;
 876          break;
 877       case GL_TEXTURE_2D:
 878          texObj = texUnit->Current2D;
 879          break;
 880       case GL_TEXTURE_3D_EXT:
 881          texObj = texUnit->Current3D;
 882          break;
 883       case GL_TEXTURE_CUBE_MAP_ARB:
 884          if (ctx->Extensions.ARB_texture_cube_map) {
 885             texObj = texUnit->CurrentCubeMap;
 886             break;
 887          }
 888          /* fallthrough */
 889       default:
 890          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
 891          return;
 892    }
 893
 894    switch (pname) {
 895       case GL_TEXTURE_MIN_FILTER:
 896          /* A small optimization */
 897          if (texObj->MinFilter == eparam)
 898             return;
 899
 900          if (eparam==GL_NEAREST || eparam==GL_LINEAR
 901              || eparam==GL_NEAREST_MIPMAP_NEAREST
 902              || eparam==GL_LINEAR_MIPMAP_NEAREST
 903              || eparam==GL_NEAREST_MIPMAP_LINEAR
 904              || eparam==GL_LINEAR_MIPMAP_LINEAR) {
 905             texObj->MinFilter = eparam;
 906          }
 907          else {
 908             _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 909             return;
 910          }
 911          break;
 912       case GL_TEXTURE_MAG_FILTER:
 913          /* A small optimization */
 914          if (texObj->MagFilter == eparam)
 915             return;
 916
 917          if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
 918             texObj->MagFilter = eparam;
 919          }
 920          else {
 921             _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 922             return;
 923          }
 924          break;
 925       case GL_TEXTURE_WRAP_S:
 926          if (texObj->WrapS == eparam)
 927             return;
 928          if (eparam==GL_CLAMP ||
 929              eparam==GL_REPEAT ||
 930              eparam==GL_CLAMP_TO_EDGE ||
 931              (eparam == GL_CLAMP_TO_BORDER_ARB &&
 932               ctx->Extensions.ARB_texture_border_clamp)) {
 933             texObj->WrapS = eparam;
 934          }
 935          else {
 936             _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 937             return;
 938          }
 939          break;
 940       case GL_TEXTURE_WRAP_T:
 941          if (texObj->WrapT == eparam)
 942             return;
 943          if (eparam==GL_CLAMP ||
 944              eparam==GL_REPEAT ||
 945              eparam==GL_CLAMP_TO_EDGE ||
 946              (eparam == GL_CLAMP_TO_BORDER_ARB &&
 947               ctx->Extensions.ARB_texture_border_clamp)) {
 948             texObj->WrapT = eparam;
 949          }
 950          else {
 951             _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 952             return;
 953          }
 954          break;
 955       case GL_TEXTURE_WRAP_R_EXT:
 956          if (texObj->WrapR == eparam)
 957             return;
 958          if (eparam==GL_CLAMP ||
 959              eparam==GL_REPEAT ||
 960              eparam==GL_CLAMP_TO_EDGE ||
 961              (eparam == GL_CLAMP_TO_BORDER_ARB &&
 962               ctx->Extensions.ARB_texture_border_clamp)) {
 963             texObj->WrapR = eparam;
 964          }
 965          else {
 966             _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 967          }
 968          break;
 969       case GL_TEXTURE_BORDER_COLOR:
 970          UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[0], params[0]);
 971          UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[1], params[1]);
 972          UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[2], params[2]);
 973          UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[3], params[3]);
 974          break;
 975       case GL_TEXTURE_MIN_LOD:
 976          texObj->MinLod = params[0];
 977          break;
 978       case GL_TEXTURE_MAX_LOD:
 979          texObj->MaxLod = params[0];
 980          break;
 981       case GL_TEXTURE_BASE_LEVEL:
 982          if (params[0] < 0.0) {
 983             _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 984             return;
 985          }
 986          texObj->BaseLevel = (GLint) params[0];
 987          break;
 988       case GL_TEXTURE_MAX_LEVEL:
 989          if (params[0] < 0.0) {
 990             _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
 991             return;
 992          }
 993          texObj->MaxLevel = (GLint) params[0];
 994          break;
 995       case GL_TEXTURE_PRIORITY:
 996          /* (keithh@netcomuk.co.uk) */
 997          texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
 998          break;
 999       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1000          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1001             if (params[0] < 1.0) {
1002                _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1003                return;
1004             }
1005             texObj->MaxAnisotropy = params[0];
1006          }
1007          else {
1008             _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1009             return;
1010          }
1011          break;
1012       case GL_TEXTURE_COMPARE_SGIX:
1013          if (ctx->Extensions.SGIX_shadow) {
1014             texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
1015          }
1016          else {
1017             _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1018             return;
1019          }
1020          break;
1021       case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1022          if (ctx->Extensions.SGIX_shadow) {
1023             GLenum op = (GLenum) params[0];
1024             if (op == GL_TEXTURE_LEQUAL_R_SGIX ||
1025                 op == GL_TEXTURE_GEQUAL_R_SGIX) {
1026                texObj->CompareOperator = op;
1027             }
1028             else {
1029                _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
1030             }
1031          }
1032          else {
1033             _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1034             return;
1035          }
1036          break;
1037       case GL_SHADOW_AMBIENT_SGIX:
1038          if (ctx->Extensions.SGIX_shadow_ambient) {
1039             UNCLAMPED_FLOAT_TO_CHAN(texObj->ShadowAmbient, params[0]);
1040          }
1041          else {
1042             _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1043             return;
1044          }
1045          break;
1046       case GL_GENERATE_MIPMAP_SGIS:
1047          if (ctx->Extensions.SGIS_generate_mipmap) {
1048             texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
1049          }
1050          else {
1051             _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1052             return;
1053          }
1054          break;
1055       default:
1056          _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(pname)" );
1057          return;
1058    }
1059
1060    ctx->NewState |= _NEW_TEXTURE;
1061    texObj->Complete = GL_FALSE;
1062
1063    if (ctx->Driver.TexParameter) {
1064       (*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
1065    }
1066 }
1067
1068
1069 void
1070 _mesa_TexParameteri( GLenum target, GLenum pname, GLint param )
1071 {
1072    GLfloat fparam[4];
1073    fparam[0] = (GLfloat) param;
1074    fparam[1] = fparam[2] = fparam[3] = 0.0;
1075    _mesa_TexParameterfv(target, pname, fparam);
1076 }
1077
1078 void
1079 _mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
1080 {
1081    GLfloat fparam[4];
1082    fparam[0] = (GLfloat) params[0];
1083    fparam[1] = fparam[2] = fparam[3] = 0.0;
1084    _mesa_TexParameterfv(target, pname, fparam);
1085 }
1086
1087
1088 void
1089 _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
1090                               GLenum pname, GLfloat *params )
1091 {
1092    GLint iparam;
1093    _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
1094    *params = (GLfloat) iparam;
1095 }
1096
1097
1098 static GLuint
1099 tex_image_dimensions(GLcontext *ctx, GLenum target)
1100 {
1101    switch (target) {
1102       case GL_TEXTURE_1D:
1103       case GL_PROXY_TEXTURE_1D:
1104          return 1;
1105       case GL_TEXTURE_2D:
1106       case GL_PROXY_TEXTURE_2D:
1107          return 2;
1108       case GL_TEXTURE_3D:
1109       case GL_PROXY_TEXTURE_3D:
1110          return 3;
1111       case GL_TEXTURE_CUBE_MAP_ARB:
1112       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
1113       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
1114       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
1115       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
1116       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
1117       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
1118       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
1119          return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
1120       default:
1121          _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
1122          return 0;
1123    }
1124 }
1125
1126
1127 void
1128 _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
1129                               GLenum pname, GLint *params )
1130 {
1131    GET_CURRENT_CONTEXT(ctx);
1132    const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1133    const struct gl_texture_image *img = NULL;
1134    GLuint dimensions;
1135    GLboolean isProxy;
1136    GLint maxLevels;
1137    ASSERT_OUTSIDE_BEGIN_END(ctx);
1138
1139    dimensions = tex_image_dimensions(ctx, target);  /* 1, 2 or 3 */
1140    if (dimensions == 0) {
1141       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
1142       return;
1143    }
1144
1145    switch (target) {
1146    case GL_TEXTURE_1D:
1147    case GL_PROXY_TEXTURE_1D:
1148    case GL_TEXTURE_2D:
1149    case GL_PROXY_TEXTURE_2D:
1150       maxLevels = ctx->Const.MaxTextureLevels;
1151       break;
1152    case GL_TEXTURE_3D:
1153    case GL_PROXY_TEXTURE_3D:
1154       maxLevels = ctx->Const.Max3DTextureLevels;
1155       break;
1156    default:
1157       maxLevels = ctx->Const.MaxCubeTextureLevels;
1158       break;
1159    }
1160
1161    if (level < 0 || level >= maxLevels) {
1162       _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
1163       return;
1164    }
1165
1166    img = _mesa_select_tex_image(ctx, texUnit, target, level);
1167    if (!img || !img->TexFormat) {
1168       /* undefined texture image */
1169       if (pname == GL_TEXTURE_COMPONENTS)
1170          *params = 1;
1171       else
1172          *params = 0;
1173       return;
1174    }
1175
1176    isProxy = (target == GL_PROXY_TEXTURE_1D) ||
1177              (target == GL_PROXY_TEXTURE_2D) ||
1178              (target == GL_PROXY_TEXTURE_3D) ||
1179              (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB);
1180
1181    switch (pname) {
1182       case GL_TEXTURE_WIDTH:
1183          *params = img->Width;
1184          return;
1185       case GL_TEXTURE_HEIGHT:
1186          *params = img->Height;
1187          return;
1188       case GL_TEXTURE_DEPTH:
1189          *params = img->Depth;
1190          return;
1191       case GL_TEXTURE_INTERNAL_FORMAT:
1192          *params = img->IntFormat;
1193          return;
1194       case GL_TEXTURE_BORDER:
1195          *params = img->Border;
1196          return;
1197       case GL_TEXTURE_RED_SIZE:
1198          if (img->Format == GL_RGB || img->Format == GL_RGBA)
1199             *params = img->TexFormat->RedBits;
1200          else
1201             *params = 0;
1202          return;
1203       case GL_TEXTURE_GREEN_SIZE:
1204          if (img->Format == GL_RGB || img->Format == GL_RGBA)
1205             *params = img->TexFormat->GreenBits;
1206          else
1207             *params = 0;
1208          return;
1209       case GL_TEXTURE_BLUE_SIZE:
1210          if (img->Format == GL_RGB || img->Format == GL_RGBA)
1211             *params = img->TexFormat->BlueBits;
1212          else
1213             *params = 0;
1214          return;
1215       case GL_TEXTURE_ALPHA_SIZE:
1216          if (img->Format == GL_ALPHA || img->Format == GL_LUMINANCE_ALPHA ||
1217              img->Format == GL_RGBA)
1218             *params = img->TexFormat->AlphaBits;
1219          else
1220             *params = 0;
1221          return;
1222       case GL_TEXTURE_INTENSITY_SIZE:
1223          if (img->Format != GL_INTENSITY)
1224             *params = 0;
1225          else if (img->TexFormat->IntensityBits > 0)
1226             *params = img->TexFormat->IntensityBits;
1227          else /* intensity probably stored as rgb texture */
1228             *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1229          return;
1230       case GL_TEXTURE_LUMINANCE_SIZE:
1231          if (img->Format != GL_LUMINANCE &&
1232              img->Format != GL_LUMINANCE_ALPHA)
1233             *params = 0;
1234          else if (img->TexFormat->LuminanceBits > 0)
1235             *params = img->TexFormat->LuminanceBits;
1236          else /* luminance probably stored as rgb texture */
1237             *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1238          return;
1239       case GL_TEXTURE_INDEX_SIZE_EXT:
1240          if (img->Format == GL_COLOR_INDEX)
1241             *params = img->TexFormat->IndexBits;
1242          else
1243             *params = 0;
1244          return;
1245       case GL_DEPTH_BITS:
1246          /* XXX this isn't in the GL_SGIX_depth_texture spec
1247           * but seems appropriate.
1248           */
1249          if (ctx->Extensions.SGIX_depth_texture)
1250             *params = img->TexFormat->DepthBits;
1251          else
1252             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1253          return;
1254
1255       /* GL_ARB_texture_compression */
1256       case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:
1257          if (ctx->Extensions.ARB_texture_compression) {
1258             if (img->IsCompressed && !isProxy)
1259                *params = img->CompressedSize;
1260             else
1261                _mesa_error(ctx, GL_INVALID_OPERATION,
1262                         "glGetTexLevelParameter[if]v(pname)");
1263          }
1264          else {
1265             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1266          }
1267          return;
1268       case GL_TEXTURE_COMPRESSED_ARB:
1269          if (ctx->Extensions.ARB_texture_compression) {
1270             *params = (GLint) img->IsCompressed;
1271          }
1272          else {
1273             _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1274          }
1275          return;
1276
1277       default:
1278          _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1279    }
1280 }
1281
1282
1283
1284 void
1285 _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
1286 {
1287    GET_CURRENT_CONTEXT(ctx);
1288    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1289    struct gl_texture_object *obj;
1290    ASSERT_OUTSIDE_BEGIN_END(ctx);
1291
1292    obj = _mesa_select_tex_object(ctx, texUnit, target);
1293    if (!obj) {
1294       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
1295       return;
1296    }
1297
1298    switch (pname) {
1299       case GL_TEXTURE_MAG_FILTER:
1300          *params = ENUM_TO_FLOAT(obj->MagFilter);
1301          return;
1302       case GL_TEXTURE_MIN_FILTER:
1303          *params = ENUM_TO_FLOAT(obj->MinFilter);
1304          return;
1305       case GL_TEXTURE_WRAP_S:
1306          *params = ENUM_TO_FLOAT(obj->WrapS);
1307          return;
1308       case GL_TEXTURE_WRAP_T:
1309          *params = ENUM_TO_FLOAT(obj->WrapT);
1310          return;
1311       case GL_TEXTURE_WRAP_R_EXT:
1312          *params = ENUM_TO_FLOAT(obj->WrapR);
1313          return;
1314       case GL_TEXTURE_BORDER_COLOR:
1315          params[0] = obj->BorderColor[0] / CHAN_MAXF;
1316          params[1] = obj->BorderColor[1] / CHAN_MAXF;
1317          params[2] = obj->BorderColor[2] / CHAN_MAXF;
1318          params[3] = obj->BorderColor[3] / CHAN_MAXF;
1319          return;
1320       case GL_TEXTURE_RESIDENT:
1321          {
1322             GLboolean resident;
1323             if (ctx->Driver.IsTextureResident)
1324                resident = ctx->Driver.IsTextureResident(ctx, obj);
1325             else
1326                resident = GL_TRUE;
1327             *params = ENUM_TO_FLOAT(resident);
1328          }
1329          return;
1330       case GL_TEXTURE_PRIORITY:
1331          *params = obj->Priority;
1332          return;
1333       case GL_TEXTURE_MIN_LOD:
1334          *params = obj->MinLod;
1335          return;
1336       case GL_TEXTURE_MAX_LOD:
1337          *params = obj->MaxLod;
1338          return;
1339       case GL_TEXTURE_BASE_LEVEL:
1340          *params = (GLfloat) obj->BaseLevel;
1341          return;
1342       case GL_TEXTURE_MAX_LEVEL:
1343          *params = (GLfloat) obj->MaxLevel;
1344          return;
1345       case GL_TEXTURE_COMPARE_SGIX:
1346          if (ctx->Extensions.SGIX_shadow) {
1347             *params = (GLfloat) obj->CompareFlag;
1348             return;
1349          }
1350          break;
1351       case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1352          if (ctx->Extensions.SGIX_shadow) {
1353             *params = (GLfloat) obj->CompareOperator;
1354             return;
1355          }
1356          break;
1357       case GL_SHADOW_AMBIENT_SGIX:
1358          if (ctx->Extensions.SGIX_shadow_ambient) {
1359             *params = CHAN_TO_FLOAT(obj->ShadowAmbient);
1360             return;
1361          }
1362          break;
1363       case GL_GENERATE_MIPMAP_SGIS:
1364          if (ctx->Extensions.SGIS_generate_mipmap) {
1365             *params = (GLfloat) obj->GenerateMipmap;
1366             return;
1367          }
1368          break;
1369       default:
1370          ; /* silence warnings */
1371    }
1372    /* If we get here, pname was an unrecognized enum */
1373    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
1374 }
1375
1376
1377 void
1378 _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1379 {
1380    GET_CURRENT_CONTEXT(ctx);
1381    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1382    struct gl_texture_object *obj;
1383    ASSERT_OUTSIDE_BEGIN_END(ctx);
1384
1385    obj = _mesa_select_tex_object(ctx, texUnit, target);
1386    if (!obj) {
1387       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
1388       return;
1389    }
1390
1391    switch (pname) {
1392       case GL_TEXTURE_MAG_FILTER:
1393          *params = (GLint) obj->MagFilter;
1394          return;
1395       case GL_TEXTURE_MIN_FILTER:
1396          *params = (GLint) obj->MinFilter;
1397          return;
1398       case GL_TEXTURE_WRAP_S:
1399          *params = (GLint) obj->WrapS;
1400          return;
1401       case GL_TEXTURE_WRAP_T:
1402          *params = (GLint) obj->WrapT;
1403          return;
1404       case GL_TEXTURE_WRAP_R_EXT:
1405          *params = (GLint) obj->WrapR;
1406          return;
1407       case GL_TEXTURE_BORDER_COLOR:
1408          {
1409             GLfloat color[4];
1410             color[0] = obj->BorderColor[0] / CHAN_MAXF;
1411             color[1] = obj->BorderColor[1] / CHAN_MAXF;
1412             color[2] = obj->BorderColor[2] / CHAN_MAXF;
1413             color[3] = obj->BorderColor[3] / CHAN_MAXF;
1414             params[0] = FLOAT_TO_INT( color[0] );
1415             params[1] = FLOAT_TO_INT( color[1] );
1416             params[2] = FLOAT_TO_INT( color[2] );
1417             params[3] = FLOAT_TO_INT( color[3] );
1418          }
1419          return;
1420       case GL_TEXTURE_RESIDENT:
1421          {
1422             GLboolean resident;
1423             if (ctx->Driver.IsTextureResident)
1424                resident = ctx->Driver.IsTextureResident(ctx, obj);
1425             else
1426                resident = GL_TRUE;
1427             *params = (GLint) resident;
1428          }
1429          return;
1430       case GL_TEXTURE_PRIORITY:
1431          *params = (GLint) obj->Priority;
1432          return;
1433       case GL_TEXTURE_MIN_LOD:
1434          *params = (GLint) obj->MinLod;
1435          return;
1436       case GL_TEXTURE_MAX_LOD:
1437          *params = (GLint) obj->MaxLod;
1438          return;
1439       case GL_TEXTURE_BASE_LEVEL:
1440          *params = obj->BaseLevel;
1441          return;
1442       case GL_TEXTURE_MAX_LEVEL:
1443          *params = obj->MaxLevel;
1444          return;
1445       case GL_TEXTURE_COMPARE_SGIX:
1446          if (ctx->Extensions.SGIX_shadow) {
1447             *params = (GLint) obj->CompareFlag;
1448             return;
1449          }
1450          break;
1451       case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1452          if (ctx->Extensions.SGIX_shadow) {
1453             *params = (GLint) obj->CompareOperator;
1454             return;
1455          }
1456          break;
1457       case GL_SHADOW_AMBIENT_SGIX:
1458          if (ctx->Extensions.SGIX_shadow_ambient) {
1459             /* XXX range? */
1460             *params = (GLint) CHAN_TO_FLOAT(obj->ShadowAmbient);
1461             return;
1462          }
1463          break;
1464       case GL_GENERATE_MIPMAP_SGIS:
1465          if (ctx->Extensions.SGIS_generate_mipmap) {
1466             *params = (GLint) obj->GenerateMipmap;
1467             return;
1468          }
1469          break;
1470       default:
1471          ; /* silence warnings */
1472    }
1473    /* If we get here, pname was an unrecognized enum */
1474    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
1475 }
1476
1477
1478
1479
1480 /**********************************************************************/
1481 /*                    Texture Coord Generation                        */
1482 /**********************************************************************/
1483
1484
1485 void
1486 _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1487 {
1488    GET_CURRENT_CONTEXT(ctx);
1489    GLuint tUnit = ctx->Texture.CurrentUnit;
1490    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1491    ASSERT_OUTSIDE_BEGIN_END(ctx);
1492
1493    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
1494       fprintf(stderr, "texGEN %s %s %x...\n",
1495               _mesa_lookup_enum_by_nr(coord),
1496               _mesa_lookup_enum_by_nr(pname),
1497               *(int *)params);
1498
1499    switch (coord) {
1500       case GL_S:
1501          if (pname==GL_TEXTURE_GEN_MODE) {
1502             GLenum mode = (GLenum) (GLint) *params;
1503             GLuint bits;
1504             switch (mode) {
1505             case GL_OBJECT_LINEAR:
1506                bits = TEXGEN_OBJ_LINEAR;
1507                break;
1508             case GL_EYE_LINEAR:
1509                bits = TEXGEN_EYE_LINEAR;
1510                break;
1511             case GL_REFLECTION_MAP_NV:
1512                bits = TEXGEN_REFLECTION_MAP_NV;
1513                break;
1514             case GL_NORMAL_MAP_NV:
1515                bits = TEXGEN_NORMAL_MAP_NV;
1516                break;
1517             case GL_SPHERE_MAP:
1518                bits = TEXGEN_SPHERE_MAP;
1519                break;
1520             default:
1521                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1522                return;
1523             }
1524             if (texUnit->GenModeS == mode)
1525                return;
1526             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1527             texUnit->GenModeS = mode;
1528             texUnit->_GenBitS = bits;
1529          }
1530          else if (pname==GL_OBJECT_PLANE) {
1531             if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
1532                 return;
1533             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1534             texUnit->ObjectPlaneS[0] = params[0];
1535             texUnit->ObjectPlaneS[1] = params[1];
1536             texUnit->ObjectPlaneS[2] = params[2];
1537             texUnit->ObjectPlaneS[3] = params[3];
1538          }
1539          else if (pname==GL_EYE_PLANE) {
1540             GLfloat tmp[4];
1541
1542             /* Transform plane equation by the inverse modelview matrix */
1543             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1544                _math_matrix_analyse( &ctx->ModelView );
1545             }
1546             _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1547             if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
1548                return;
1549             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1550             COPY_4FV(texUnit->EyePlaneS, tmp);
1551          }
1552          else {
1553             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1554             return;
1555          }
1556          break;
1557       case GL_T:
1558          if (pname==GL_TEXTURE_GEN_MODE) {
1559             GLenum mode = (GLenum) (GLint) *params;
1560             GLuint bitt;
1561             switch (mode) {
1562                case GL_OBJECT_LINEAR:
1563                   bitt = TEXGEN_OBJ_LINEAR;
1564                   break;
1565                case GL_EYE_LINEAR:
1566                   bitt = TEXGEN_EYE_LINEAR;
1567                   break;
1568                case GL_REFLECTION_MAP_NV:
1569                   bitt = TEXGEN_REFLECTION_MAP_NV;
1570                   break;
1571                case GL_NORMAL_MAP_NV:
1572                   bitt = TEXGEN_NORMAL_MAP_NV;
1573                   break;
1574                case GL_SPHERE_MAP:
1575                   bitt = TEXGEN_SPHERE_MAP;
1576                   break;
1577                default:
1578                   _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1579                   return;
1580             }
1581             if (texUnit->GenModeT == mode)
1582                return;
1583             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1584             texUnit->GenModeT = mode;
1585             texUnit->_GenBitT = bitt;
1586          }
1587          else if (pname==GL_OBJECT_PLANE) {
1588             if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
1589                 return;
1590             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1591             texUnit->ObjectPlaneT[0] = params[0];
1592             texUnit->ObjectPlaneT[1] = params[1];
1593             texUnit->ObjectPlaneT[2] = params[2];
1594             texUnit->ObjectPlaneT[3] = params[3];
1595          }
1596          else if (pname==GL_EYE_PLANE) {
1597             GLfloat tmp[4];
1598             /* Transform plane equation by the inverse modelview matrix */
1599             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1600                _math_matrix_analyse( &ctx->ModelView );
1601             }
1602             _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1603             if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
1604                 return;
1605             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1606             COPY_4FV(texUnit->EyePlaneT, tmp);
1607          }
1608          else {
1609             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1610             return;
1611          }
1612          break;
1613       case GL_R:
1614          if (pname==GL_TEXTURE_GEN_MODE) {
1615             GLenum mode = (GLenum) (GLint) *params;
1616             GLuint bitr;
1617             switch (mode) {
1618             case GL_OBJECT_LINEAR:
1619                bitr = TEXGEN_OBJ_LINEAR;
1620                break;
1621             case GL_REFLECTION_MAP_NV:
1622                bitr = TEXGEN_REFLECTION_MAP_NV;
1623                break;
1624             case GL_NORMAL_MAP_NV:
1625                bitr = TEXGEN_NORMAL_MAP_NV;
1626                break;
1627             case GL_EYE_LINEAR:
1628                bitr = TEXGEN_EYE_LINEAR;
1629                break;
1630             default:
1631                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1632                return;
1633             }
1634             if (texUnit->GenModeR == mode)
1635                return;
1636             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1637             texUnit->GenModeR = mode;
1638             texUnit->_GenBitR = bitr;
1639          }
1640          else if (pname==GL_OBJECT_PLANE) {
1641             if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
1642                 return;
1643             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1644             texUnit->ObjectPlaneR[0] = params[0];
1645             texUnit->ObjectPlaneR[1] = params[1];
1646             texUnit->ObjectPlaneR[2] = params[2];
1647             texUnit->ObjectPlaneR[3] = params[3];
1648          }
1649          else if (pname==GL_EYE_PLANE) {
1650             GLfloat tmp[4];
1651             /* Transform plane equation by the inverse modelview matrix */
1652             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1653                _math_matrix_analyse( &ctx->ModelView );
1654             }
1655             _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1656             if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
1657                return;
1658             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1659             COPY_4FV(texUnit->EyePlaneR, tmp);
1660          }
1661          else {
1662             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1663             return;
1664          }
1665          break;
1666       case GL_Q:
1667          if (pname==GL_TEXTURE_GEN_MODE) {
1668             GLenum mode = (GLenum) (GLint) *params;
1669             GLuint bitq;
1670             switch (mode) {
1671             case GL_OBJECT_LINEAR:
1672                bitq = TEXGEN_OBJ_LINEAR;
1673                break;
1674             case GL_EYE_LINEAR:
1675                bitq = TEXGEN_EYE_LINEAR;
1676                break;
1677             default:
1678                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1679                return;
1680             }
1681             if (texUnit->GenModeQ == mode)
1682                return;
1683             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1684             texUnit->GenModeQ = mode;
1685             texUnit->_GenBitQ = bitq;
1686          }
1687          else if (pname==GL_OBJECT_PLANE) {
1688             if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
1689                 return;
1690             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1691             texUnit->ObjectPlaneQ[0] = params[0];
1692             texUnit->ObjectPlaneQ[1] = params[1];
1693             texUnit->ObjectPlaneQ[2] = params[2];
1694             texUnit->ObjectPlaneQ[3] = params[3];
1695          }
1696          else if (pname==GL_EYE_PLANE) {
1697             GLfloat tmp[4];
1698             /* Transform plane equation by the inverse modelview matrix */
1699             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1700                _math_matrix_analyse( &ctx->ModelView );
1701             }
1702             _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1703             if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
1704                return;
1705             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1706             COPY_4FV(texUnit->EyePlaneQ, tmp);
1707          }
1708          else {
1709             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1710             return;
1711          }
1712          break;
1713       default:
1714          _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
1715          return;
1716    }
1717
1718    if (ctx->Driver.TexGen)
1719       ctx->Driver.TexGen( ctx, coord, pname, params );
1720 }
1721
1722
1723 void
1724 _mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
1725 {
1726    GLfloat p[4];
1727    p[0] = params[0];
1728    p[1] = params[1];
1729    p[2] = params[2];
1730    p[3] = params[3];
1731    _mesa_TexGenfv(coord, pname, p);
1732 }
1733
1734
1735 void
1736 _mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
1737 {
1738    GLfloat p = (GLfloat) param;
1739    _mesa_TexGenfv( coord, pname, &p );
1740 }
1741
1742
1743 void
1744 _mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
1745 {
1746    GLfloat p[4];
1747    p[0] = params[0];
1748    p[1] = params[1];
1749    p[2] = params[2];
1750    p[3] = params[3];
1751    _mesa_TexGenfv( coord, pname, p );
1752 }
1753
1754
1755 void
1756 _mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
1757 {
1758    _mesa_TexGenfv(coord, pname, &param);
1759 }
1760
1761
1762 void
1763 _mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
1764 {
1765    _mesa_TexGeniv( coord, pname, &param );
1766 }
1767
1768
1769
1770 void
1771 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
1772 {
1773    GET_CURRENT_CONTEXT(ctx);
1774    GLuint tUnit = ctx->Texture.CurrentUnit;
1775    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1776    ASSERT_OUTSIDE_BEGIN_END(ctx);
1777
1778    switch (coord) {
1779       case GL_S:
1780          if (pname==GL_TEXTURE_GEN_MODE) {
1781             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
1782          }
1783          else if (pname==GL_OBJECT_PLANE) {
1784             COPY_4V( params, texUnit->ObjectPlaneS );
1785          }
1786          else if (pname==GL_EYE_PLANE) {
1787             COPY_4V( params, texUnit->EyePlaneS );
1788          }
1789          else {
1790             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1791             return;
1792          }
1793          break;
1794       case GL_T:
1795          if (pname==GL_TEXTURE_GEN_MODE) {
1796             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
1797          }
1798          else if (pname==GL_OBJECT_PLANE) {
1799             COPY_4V( params, texUnit->ObjectPlaneT );
1800          }
1801          else if (pname==GL_EYE_PLANE) {
1802             COPY_4V( params, texUnit->EyePlaneT );
1803          }
1804          else {
1805             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1806             return;
1807          }
1808          break;
1809       case GL_R:
1810          if (pname==GL_TEXTURE_GEN_MODE) {
1811             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
1812          }
1813          else if (pname==GL_OBJECT_PLANE) {
1814             COPY_4V( params, texUnit->ObjectPlaneR );
1815          }
1816          else if (pname==GL_EYE_PLANE) {
1817             COPY_4V( params, texUnit->EyePlaneR );
1818          }
1819          else {
1820             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1821             return;
1822          }
1823          break;
1824       case GL_Q:
1825          if (pname==GL_TEXTURE_GEN_MODE) {
1826             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
1827          }
1828          else if (pname==GL_OBJECT_PLANE) {
1829             COPY_4V( params, texUnit->ObjectPlaneQ );
1830          }
1831          else if (pname==GL_EYE_PLANE) {
1832             COPY_4V( params, texUnit->EyePlaneQ );
1833          }
1834          else {
1835             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1836             return;
1837          }
1838          break;
1839       default:
1840          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
1841          return;
1842    }
1843 }
1844
1845
1846
1847 void
1848 _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
1849 {
1850    GET_CURRENT_CONTEXT(ctx);
1851    GLuint tUnit = ctx->Texture.CurrentUnit;
1852    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1853    ASSERT_OUTSIDE_BEGIN_END(ctx);
1854
1855    switch (coord) {
1856       case GL_S:
1857          if (pname==GL_TEXTURE_GEN_MODE) {
1858             params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
1859          }
1860          else if (pname==GL_OBJECT_PLANE) {
1861             COPY_4V( params, texUnit->ObjectPlaneS );
1862          }
1863          else if (pname==GL_EYE_PLANE) {
1864             COPY_4V( params, texUnit->EyePlaneS );
1865          }
1866          else {
1867             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1868             return;
1869          }
1870          break;
1871       case GL_T:
1872          if (pname==GL_TEXTURE_GEN_MODE) {
1873             params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
1874          }
1875          else if (pname==GL_OBJECT_PLANE) {
1876             COPY_4V( params, texUnit->ObjectPlaneT );
1877          }
1878          else if (pname==GL_EYE_PLANE) {
1879             COPY_4V( params, texUnit->EyePlaneT );
1880          }
1881          else {
1882             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1883             return;
1884          }
1885          break;
1886       case GL_R:
1887          if (pname==GL_TEXTURE_GEN_MODE) {
1888             params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
1889          }
1890          else if (pname==GL_OBJECT_PLANE) {
1891             COPY_4V( params, texUnit->ObjectPlaneR );
1892          }
1893          else if (pname==GL_EYE_PLANE) {
1894             COPY_4V( params, texUnit->EyePlaneR );
1895          }
1896          else {
1897             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1898             return;
1899          }
1900          break;
1901       case GL_Q:
1902          if (pname==GL_TEXTURE_GEN_MODE) {
1903             params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
1904          }
1905          else if (pname==GL_OBJECT_PLANE) {
1906             COPY_4V( params, texUnit->ObjectPlaneQ );
1907          }
1908          else if (pname==GL_EYE_PLANE) {
1909             COPY_4V( params, texUnit->EyePlaneQ );
1910          }
1911          else {
1912             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1913             return;
1914          }
1915          break;
1916       default:
1917          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
1918          return;
1919    }
1920 }
1921
1922
1923
1924 void
1925 _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
1926 {
1927    GET_CURRENT_CONTEXT(ctx);
1928    GLuint tUnit = ctx->Texture.CurrentUnit;
1929    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1930    ASSERT_OUTSIDE_BEGIN_END(ctx);
1931
1932    switch (coord) {
1933       case GL_S:
1934          if (pname==GL_TEXTURE_GEN_MODE) {
1935             params[0] = texUnit->GenModeS;
1936          }
1937          else if (pname==GL_OBJECT_PLANE) {
1938             params[0] = (GLint) texUnit->ObjectPlaneS[0];
1939             params[1] = (GLint) texUnit->ObjectPlaneS[1];
1940             params[2] = (GLint) texUnit->ObjectPlaneS[2];
1941             params[3] = (GLint) texUnit->ObjectPlaneS[3];
1942          }
1943          else if (pname==GL_EYE_PLANE) {
1944             params[0] = (GLint) texUnit->EyePlaneS[0];
1945             params[1] = (GLint) texUnit->EyePlaneS[1];
1946             params[2] = (GLint) texUnit->EyePlaneS[2];
1947             params[3] = (GLint) texUnit->EyePlaneS[3];
1948          }
1949          else {
1950             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1951             return;
1952          }
1953          break;
1954       case GL_T:
1955          if (pname==GL_TEXTURE_GEN_MODE) {
1956             params[0] = texUnit->GenModeT;
1957          }
1958          else if (pname==GL_OBJECT_PLANE) {
1959             params[0] = (GLint) texUnit->ObjectPlaneT[0];
1960             params[1] = (GLint) texUnit->ObjectPlaneT[1];
1961             params[2] = (GLint) texUnit->ObjectPlaneT[2];
1962             params[3] = (GLint) texUnit->ObjectPlaneT[3];
1963          }
1964          else if (pname==GL_EYE_PLANE) {
1965             params[0] = (GLint) texUnit->EyePlaneT[0];
1966             params[1] = (GLint) texUnit->EyePlaneT[1];
1967             params[2] = (GLint) texUnit->EyePlaneT[2];
1968             params[3] = (GLint) texUnit->EyePlaneT[3];
1969          }
1970          else {
1971             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1972             return;
1973          }
1974          break;
1975       case GL_R:
1976          if (pname==GL_TEXTURE_GEN_MODE) {
1977             params[0] = texUnit->GenModeR;
1978          }
1979          else if (pname==GL_OBJECT_PLANE) {
1980             params[0] = (GLint) texUnit->ObjectPlaneR[0];
1981             params[1] = (GLint) texUnit->ObjectPlaneR[1];
1982             params[2] = (GLint) texUnit->ObjectPlaneR[2];
1983             params[3] = (GLint) texUnit->ObjectPlaneR[3];
1984          }
1985          else if (pname==GL_EYE_PLANE) {
1986             params[0] = (GLint) texUnit->EyePlaneR[0];
1987             params[1] = (GLint) texUnit->EyePlaneR[1];
1988             params[2] = (GLint) texUnit->EyePlaneR[2];
1989             params[3] = (GLint) texUnit->EyePlaneR[3];
1990          }
1991          else {
1992             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1993             return;
1994          }
1995          break;
1996       case GL_Q:
1997          if (pname==GL_TEXTURE_GEN_MODE) {
1998             params[0] = texUnit->GenModeQ;
1999          }
2000          else if (pname==GL_OBJECT_PLANE) {
2001             params[0] = (GLint) texUnit->ObjectPlaneQ[0];
2002             params[1] = (GLint) texUnit->ObjectPlaneQ[1];
2003             params[2] = (GLint) texUnit->ObjectPlaneQ[2];
2004             params[3] = (GLint) texUnit->ObjectPlaneQ[3];
2005          }
2006          else if (pname==GL_EYE_PLANE) {
2007             params[0] = (GLint) texUnit->EyePlaneQ[0];
2008             params[1] = (GLint) texUnit->EyePlaneQ[1];
2009             params[2] = (GLint) texUnit->EyePlaneQ[2];
2010             params[3] = (GLint) texUnit->EyePlaneQ[3];
2011          }
2012          else {
2013             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
2014             return;
2015          }
2016          break;
2017       default:
2018          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
2019          return;
2020    }
2021 }
2022
2023
2024 /* GL_ARB_multitexture */
2025 void
2026 _mesa_ActiveTextureARB( GLenum target )
2027 {
2028    GET_CURRENT_CONTEXT(ctx);
2029    GLuint texUnit = target - GL_TEXTURE0_ARB;
2030    ASSERT_OUTSIDE_BEGIN_END(ctx);
2031
2032    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
2033       fprintf(stderr, "glActiveTexture %s\n",
2034               _mesa_lookup_enum_by_nr(target));
2035
2036    if (texUnit > ctx->Const.MaxTextureUnits) {
2037       _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
2038       return;
2039    }
2040
2041    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2042    ctx->Texture.CurrentUnit = texUnit;
2043    if (ctx->Driver.ActiveTexture) {
2044       (*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
2045    }
2046 }
2047
2048
2049 /* GL_ARB_multitexture */
2050 void
2051 _mesa_ClientActiveTextureARB( GLenum target )
2052 {
2053    GET_CURRENT_CONTEXT(ctx);
2054    GLuint texUnit = target - GL_TEXTURE0_ARB;
2055    ASSERT_OUTSIDE_BEGIN_END(ctx);
2056
2057    if (texUnit > ctx->Const.MaxTextureUnits) {
2058       _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
2059       return;
2060    }
2061
2062    FLUSH_VERTICES(ctx, _NEW_ARRAY);
2063    ctx->Array.ActiveTexture = texUnit;
2064 }
2065
2066
2067
2068 /**********************************************************************/
2069 /*                     Pixel Texgen Extensions                        */
2070 /**********************************************************************/
2071
2072 void
2073 _mesa_PixelTexGenSGIX(GLenum mode)
2074 {
2075    GLenum newRgbSource, newAlphaSource;
2076    GET_CURRENT_CONTEXT(ctx);
2077    ASSERT_OUTSIDE_BEGIN_END(ctx);
2078
2079    switch (mode) {
2080       case GL_NONE:
2081          newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
2082          newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
2083          break;
2084       case GL_ALPHA:
2085          newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
2086          newAlphaSource = GL_CURRENT_RASTER_COLOR;
2087          break;
2088       case GL_RGB:
2089          newRgbSource = GL_CURRENT_RASTER_COLOR;
2090          newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
2091          break;
2092       case GL_RGBA:
2093          newRgbSource = GL_CURRENT_RASTER_COLOR;
2094          newAlphaSource = GL_CURRENT_RASTER_COLOR;
2095          break;
2096       default:
2097          _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenSGIX(mode)");
2098          return;
2099    }
2100
2101    if (newRgbSource == ctx->Pixel.FragmentRgbSource &&
2102        newAlphaSource == ctx->Pixel.FragmentAlphaSource)
2103       return;
2104
2105    FLUSH_VERTICES(ctx, _NEW_PIXEL);
2106    ctx->Pixel.FragmentRgbSource = newRgbSource;
2107    ctx->Pixel.FragmentAlphaSource = newAlphaSource;
2108 }
2109
2110
2111 void
2112 _mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
2113 {
2114    _mesa_PixelTexGenParameteriSGIS(target, (GLint) value);
2115 }
2116
2117
2118 void
2119 _mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
2120 {
2121    _mesa_PixelTexGenParameteriSGIS(target, (GLint) *value);
2122 }
2123
2124
2125 void
2126 _mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value)
2127 {
2128    GET_CURRENT_CONTEXT(ctx);
2129    ASSERT_OUTSIDE_BEGIN_END(ctx);
2130
2131    if (value != GL_CURRENT_RASTER_COLOR && value != GL_PIXEL_GROUP_COLOR_SGIS) {
2132       _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(value)");
2133       return;
2134    }
2135
2136    switch (target) {
2137    case GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS:
2138       if (ctx->Pixel.FragmentRgbSource == (GLenum) value)
2139          return;
2140       FLUSH_VERTICES(ctx, _NEW_PIXEL);
2141       ctx->Pixel.FragmentRgbSource = (GLenum) value;
2142       break;
2143    case GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS:
2144       if (ctx->Pixel.FragmentAlphaSource == (GLenum) value)
2145          return;
2146       FLUSH_VERTICES(ctx, _NEW_PIXEL);
2147       ctx->Pixel.FragmentAlphaSource = (GLenum) value;
2148       break;
2149    default:
2150       _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(target)");
2151       return;
2152    }
2153 }
2154
2155
2156 void
2157 _mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
2158 {
2159   _mesa_PixelTexGenParameteriSGIS(target, *value);
2160 }
2161
2162
2163 void
2164 _mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
2165 {
2166    GET_CURRENT_CONTEXT(ctx);
2167    ASSERT_OUTSIDE_BEGIN_END(ctx);
2168
2169    if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
2170       *value = (GLfloat) ctx->Pixel.FragmentRgbSource;
2171    }
2172    else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
2173       *value = (GLfloat) ctx->Pixel.FragmentAlphaSource;
2174    }
2175    else {
2176       _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterfvSGIS(target)");
2177    }
2178 }
2179
2180
2181 void
2182 _mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
2183 {
2184    GET_CURRENT_CONTEXT(ctx);
2185    ASSERT_OUTSIDE_BEGIN_END(ctx);
2186
2187    if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
2188       *value = (GLint) ctx->Pixel.FragmentRgbSource;
2189    }
2190    else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
2191       *value = (GLint) ctx->Pixel.FragmentAlphaSource;
2192    }
2193    else {
2194       _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterivSGIS(target)");
2195    }
2196 }