src/mesa/main/texgen.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file texgen.c
  27  *
  28  * glTexGen-related functions
  29  */
  30
  31
  32 #include "main/glheader.h"
  33 #include "main/context.h"
  34 #include "main/enums.h"
  35 #include "main/macros.h"
  36 #include "main/texgen.h"
  37 #include "math/m_xform.h"
  38
  39
  40 #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
  41 #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
  42
  43
  44
  45 void GLAPIENTRY
  46 _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
  47 {
  48    GET_CURRENT_CONTEXT(ctx);
  49    struct gl_texture_unit *texUnit;
  50    ASSERT_OUTSIDE_BEGIN_END(ctx);
  51
  52    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
  53       _mesa_debug(ctx, "glTexGen %s %s %.1f(%s)...\n",
  54                   _mesa_lookup_enum_by_nr(coord),
  55                   _mesa_lookup_enum_by_nr(pname),
  56                   *params,
  57                   _mesa_lookup_enum_by_nr((GLenum) (GLint) *params));
  58
  59    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
  60       _mesa_error(ctx, GL_INVALID_OPERATION, "glTexGen(current unit)");
  61       return;
  62    }
  63
  64    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  65
  66    switch (coord) {
  67       case GL_S:
  68          if (pname==GL_TEXTURE_GEN_MODE) {
  69             GLenum mode = (GLenum) (GLint) *params;
  70             GLbitfield bits;
  71             switch (mode) {
  72             case GL_OBJECT_LINEAR:
  73                bits = TEXGEN_OBJ_LINEAR;
  74                break;
  75             case GL_EYE_LINEAR:
  76                bits = TEXGEN_EYE_LINEAR;
  77                break;
  78             case GL_REFLECTION_MAP_NV:
  79                bits = TEXGEN_REFLECTION_MAP_NV;
  80                break;
  81             case GL_NORMAL_MAP_NV:
  82                bits = TEXGEN_NORMAL_MAP_NV;
  83                break;
  84             case GL_SPHERE_MAP:
  85                bits = TEXGEN_SPHERE_MAP;
  86                break;
  87             default:
  88                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
  89                return;
  90             }
  91             if (texUnit->GenModeS == mode)
  92                return;
  93             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  94             texUnit->GenModeS = mode;
  95             texUnit->_GenBitS = bits;
  96          }
  97          else if (pname==GL_OBJECT_PLANE) {
  98             if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
  99                 return;
 100             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 101             COPY_4FV(texUnit->ObjectPlaneS, params);
 102          }
 103          else if (pname==GL_EYE_PLANE) {
 104             GLfloat tmp[4];
 105             /* Transform plane equation by the inverse modelview matrix */
 106             if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
 107                _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
 108             }
 109             _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
 110             if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
 111                return;
 112             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 113             COPY_4FV(texUnit->EyePlaneS, tmp);
 114          }
 115          else {
 116             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 117             return;
 118          }
 119          break;
 120       case GL_T:
 121          if (pname==GL_TEXTURE_GEN_MODE) {
 122             GLenum mode = (GLenum) (GLint) *params;
 123             GLbitfield bitt;
 124             switch (mode) {
 125                case GL_OBJECT_LINEAR:
 126                   bitt = TEXGEN_OBJ_LINEAR;
 127                   break;
 128                case GL_EYE_LINEAR:
 129                   bitt = TEXGEN_EYE_LINEAR;
 130                   break;
 131                case GL_REFLECTION_MAP_NV:
 132                   bitt = TEXGEN_REFLECTION_MAP_NV;
 133                   break;
 134                case GL_NORMAL_MAP_NV:
 135                   bitt = TEXGEN_NORMAL_MAP_NV;
 136                   break;
 137                case GL_SPHERE_MAP:
 138                   bitt = TEXGEN_SPHERE_MAP;
 139                   break;
 140                default:
 141                   _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 142                   return;
 143             }
 144             if (texUnit->GenModeT == mode)
 145                return;
 146             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 147             texUnit->GenModeT = mode;
 148             texUnit->_GenBitT = bitt;
 149          }
 150          else if (pname==GL_OBJECT_PLANE) {
 151             if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
 152                 return;
 153             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 154             COPY_4FV(texUnit->ObjectPlaneT, params);
 155          }
 156          else if (pname==GL_EYE_PLANE) {
 157             GLfloat tmp[4];
 158             /* Transform plane equation by the inverse modelview matrix */
 159             if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
 160                _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
 161             }
 162             _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
 163             if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
 164                 return;
 165             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 166             COPY_4FV(texUnit->EyePlaneT, tmp);
 167          }
 168          else {
 169             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 170             return;
 171          }
 172          break;
 173       case GL_R:
 174          if (pname==GL_TEXTURE_GEN_MODE) {
 175             GLenum mode = (GLenum) (GLint) *params;
 176             GLbitfield bitr;
 177             switch (mode) {
 178             case GL_OBJECT_LINEAR:
 179                bitr = TEXGEN_OBJ_LINEAR;
 180                break;
 181             case GL_REFLECTION_MAP_NV:
 182                bitr = TEXGEN_REFLECTION_MAP_NV;
 183                break;
 184             case GL_NORMAL_MAP_NV:
 185                bitr = TEXGEN_NORMAL_MAP_NV;
 186                break;
 187             case GL_EYE_LINEAR:
 188                bitr = TEXGEN_EYE_LINEAR;
 189                break;
 190             default:
 191                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 192                return;
 193             }
 194             if (texUnit->GenModeR == mode)
 195                return;
 196             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 197             texUnit->GenModeR = mode;
 198             texUnit->_GenBitR = bitr;
 199          }
 200          else if (pname==GL_OBJECT_PLANE) {
 201             if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
 202                 return;
 203             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 204             COPY_4FV(texUnit->ObjectPlaneR, params);
 205          }
 206          else if (pname==GL_EYE_PLANE) {
 207             GLfloat tmp[4];
 208             /* Transform plane equation by the inverse modelview matrix */
 209             if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
 210                _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
 211             }
 212             _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
 213             if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
 214                return;
 215             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 216             COPY_4FV(texUnit->EyePlaneR, tmp);
 217          }
 218          else {
 219             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 220             return;
 221          }
 222          break;
 223       case GL_Q:
 224          if (pname==GL_TEXTURE_GEN_MODE) {
 225             GLenum mode = (GLenum) (GLint) *params;
 226             GLbitfield bitq;
 227             switch (mode) {
 228             case GL_OBJECT_LINEAR:
 229                bitq = TEXGEN_OBJ_LINEAR;
 230                break;
 231             case GL_EYE_LINEAR:
 232                bitq = TEXGEN_EYE_LINEAR;
 233                break;
 234             default:
 235                _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 236                return;
 237             }
 238             if (texUnit->GenModeQ == mode)
 239                return;
 240             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 241             texUnit->GenModeQ = mode;
 242             texUnit->_GenBitQ = bitq;
 243          }
 244          else if (pname==GL_OBJECT_PLANE) {
 245             if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
 246                 return;
 247             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 248             COPY_4FV(texUnit->ObjectPlaneQ, params);
 249          }
 250          else if (pname==GL_EYE_PLANE) {
 251             GLfloat tmp[4];
 252             /* Transform plane equation by the inverse modelview matrix */
 253             if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
 254                _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
 255             }
 256             _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
 257             if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
 258                return;
 259             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 260             COPY_4FV(texUnit->EyePlaneQ, tmp);
 261          }
 262          else {
 263             _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 264             return;
 265          }
 266          break;
 267       default:
 268          _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
 269          return;
 270    }
 271
 272    if (ctx->Driver.TexGen)
 273       ctx->Driver.TexGen( ctx, coord, pname, params );
 274 }
 275
 276
 277 void GLAPIENTRY
 278 _mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
 279 {
 280    GLfloat p[4];
 281    p[0] = (GLfloat) params[0];
 282    if (pname == GL_TEXTURE_GEN_MODE) {
 283       p[1] = p[2] = p[3] = 0.0F;
 284    }
 285    else {
 286       p[1] = (GLfloat) params[1];
 287       p[2] = (GLfloat) params[2];
 288       p[3] = (GLfloat) params[3];
 289    }
 290    _mesa_TexGenfv(coord, pname, p);
 291 }
 292
 293
 294 void GLAPIENTRY
 295 _mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
 296 {
 297    GLfloat p = (GLfloat) param;
 298    _mesa_TexGenfv( coord, pname, &p );
 299 }
 300
 301
 302 void GLAPIENTRY
 303 _mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
 304 {
 305    GLfloat p[4];
 306    p[0] = (GLfloat) params[0];
 307    if (pname == GL_TEXTURE_GEN_MODE) {
 308       p[1] = p[2] = p[3] = 0.0F;
 309    }
 310    else {
 311       p[1] = (GLfloat) params[1];
 312       p[2] = (GLfloat) params[2];
 313       p[3] = (GLfloat) params[3];
 314    }
 315    _mesa_TexGenfv( coord, pname, p );
 316 }
 317
 318
 319 void GLAPIENTRY
 320 _mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
 321 {
 322    _mesa_TexGenfv(coord, pname, &param);
 323 }
 324
 325
 326 void GLAPIENTRY
 327 _mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
 328 {
 329    _mesa_TexGeniv( coord, pname, &param );
 330 }
 331
 332
 333
 334 void GLAPIENTRY
 335 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
 336 {
 337    const struct gl_texture_unit *texUnit;
 338    GET_CURRENT_CONTEXT(ctx);
 339    ASSERT_OUTSIDE_BEGIN_END(ctx);
 340
 341    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 342       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexGendv(current unit)");
 343       return;
 344    }
 345
 346    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 347
 348    switch (coord) {
 349       case GL_S:
 350          if (pname==GL_TEXTURE_GEN_MODE) {
 351             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
 352          }
 353          else if (pname==GL_OBJECT_PLANE) {
 354             COPY_4V( params, texUnit->ObjectPlaneS );
 355          }
 356          else if (pname==GL_EYE_PLANE) {
 357             COPY_4V( params, texUnit->EyePlaneS );
 358          }
 359          else {
 360             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 361             return;
 362          }
 363          break;
 364       case GL_T:
 365          if (pname==GL_TEXTURE_GEN_MODE) {
 366             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
 367          }
 368          else if (pname==GL_OBJECT_PLANE) {
 369             COPY_4V( params, texUnit->ObjectPlaneT );
 370          }
 371          else if (pname==GL_EYE_PLANE) {
 372             COPY_4V( params, texUnit->EyePlaneT );
 373          }
 374          else {
 375             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 376             return;
 377          }
 378          break;
 379       case GL_R:
 380          if (pname==GL_TEXTURE_GEN_MODE) {
 381             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
 382          }
 383          else if (pname==GL_OBJECT_PLANE) {
 384             COPY_4V( params, texUnit->ObjectPlaneR );
 385          }
 386          else if (pname==GL_EYE_PLANE) {
 387             COPY_4V( params, texUnit->EyePlaneR );
 388          }
 389          else {
 390             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 391             return;
 392          }
 393          break;
 394       case GL_Q:
 395          if (pname==GL_TEXTURE_GEN_MODE) {
 396             params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
 397          }
 398          else if (pname==GL_OBJECT_PLANE) {
 399             COPY_4V( params, texUnit->ObjectPlaneQ );
 400          }
 401          else if (pname==GL_EYE_PLANE) {
 402             COPY_4V( params, texUnit->EyePlaneQ );
 403          }
 404          else {
 405             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 406             return;
 407          }
 408          break;
 409       default:
 410          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
 411          return;
 412    }
 413 }
 414
 415
 416
 417 void GLAPIENTRY
 418 _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
 419 {
 420    const struct gl_texture_unit *texUnit;
 421    GET_CURRENT_CONTEXT(ctx);
 422    ASSERT_OUTSIDE_BEGIN_END(ctx);
 423
 424    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 425       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexGenfv(current unit)");
 426       return;
 427    }
 428
 429    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 430
 431    switch (coord) {
 432       case GL_S:
 433          if (pname==GL_TEXTURE_GEN_MODE) {
 434             params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
 435          }
 436          else if (pname==GL_OBJECT_PLANE) {
 437             COPY_4V( params, texUnit->ObjectPlaneS );
 438          }
 439          else if (pname==GL_EYE_PLANE) {
 440             COPY_4V( params, texUnit->EyePlaneS );
 441          }
 442          else {
 443             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 444             return;
 445          }
 446          break;
 447       case GL_T:
 448          if (pname==GL_TEXTURE_GEN_MODE) {
 449             params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
 450          }
 451          else if (pname==GL_OBJECT_PLANE) {
 452             COPY_4V( params, texUnit->ObjectPlaneT );
 453          }
 454          else if (pname==GL_EYE_PLANE) {
 455             COPY_4V( params, texUnit->EyePlaneT );
 456          }
 457          else {
 458             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 459             return;
 460          }
 461          break;
 462       case GL_R:
 463          if (pname==GL_TEXTURE_GEN_MODE) {
 464             params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
 465          }
 466          else if (pname==GL_OBJECT_PLANE) {
 467             COPY_4V( params, texUnit->ObjectPlaneR );
 468          }
 469          else if (pname==GL_EYE_PLANE) {
 470             COPY_4V( params, texUnit->EyePlaneR );
 471          }
 472          else {
 473             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 474             return;
 475          }
 476          break;
 477       case GL_Q:
 478          if (pname==GL_TEXTURE_GEN_MODE) {
 479             params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
 480          }
 481          else if (pname==GL_OBJECT_PLANE) {
 482             COPY_4V( params, texUnit->ObjectPlaneQ );
 483          }
 484          else if (pname==GL_EYE_PLANE) {
 485             COPY_4V( params, texUnit->EyePlaneQ );
 486          }
 487          else {
 488             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 489             return;
 490          }
 491          break;
 492       default:
 493          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
 494          return;
 495    }
 496 }
 497
 498
 499
 500 void GLAPIENTRY
 501 _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
 502 {
 503    const struct gl_texture_unit *texUnit;
 504    GET_CURRENT_CONTEXT(ctx);
 505    ASSERT_OUTSIDE_BEGIN_END(ctx);
 506
 507    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 508       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexGeniv(current unit)");
 509       return;
 510    }
 511
 512    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 513
 514    switch (coord) {
 515       case GL_S:
 516          if (pname==GL_TEXTURE_GEN_MODE) {
 517             params[0] = texUnit->GenModeS;
 518          }
 519          else if (pname==GL_OBJECT_PLANE) {
 520             params[0] = (GLint) texUnit->ObjectPlaneS[0];
 521             params[1] = (GLint) texUnit->ObjectPlaneS[1];
 522             params[2] = (GLint) texUnit->ObjectPlaneS[2];
 523             params[3] = (GLint) texUnit->ObjectPlaneS[3];
 524          }
 525          else if (pname==GL_EYE_PLANE) {
 526             params[0] = (GLint) texUnit->EyePlaneS[0];
 527             params[1] = (GLint) texUnit->EyePlaneS[1];
 528             params[2] = (GLint) texUnit->EyePlaneS[2];
 529             params[3] = (GLint) texUnit->EyePlaneS[3];
 530          }
 531          else {
 532             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 533             return;
 534          }
 535          break;
 536       case GL_T:
 537          if (pname==GL_TEXTURE_GEN_MODE) {
 538             params[0] = texUnit->GenModeT;
 539          }
 540          else if (pname==GL_OBJECT_PLANE) {
 541             params[0] = (GLint) texUnit->ObjectPlaneT[0];
 542             params[1] = (GLint) texUnit->ObjectPlaneT[1];
 543             params[2] = (GLint) texUnit->ObjectPlaneT[2];
 544             params[3] = (GLint) texUnit->ObjectPlaneT[3];
 545          }
 546          else if (pname==GL_EYE_PLANE) {
 547             params[0] = (GLint) texUnit->EyePlaneT[0];
 548             params[1] = (GLint) texUnit->EyePlaneT[1];
 549             params[2] = (GLint) texUnit->EyePlaneT[2];
 550             params[3] = (GLint) texUnit->EyePlaneT[3];
 551          }
 552          else {
 553             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 554             return;
 555          }
 556          break;
 557       case GL_R:
 558          if (pname==GL_TEXTURE_GEN_MODE) {
 559             params[0] = texUnit->GenModeR;
 560          }
 561          else if (pname==GL_OBJECT_PLANE) {
 562             params[0] = (GLint) texUnit->ObjectPlaneR[0];
 563             params[1] = (GLint) texUnit->ObjectPlaneR[1];
 564             params[2] = (GLint) texUnit->ObjectPlaneR[2];
 565             params[3] = (GLint) texUnit->ObjectPlaneR[3];
 566          }
 567          else if (pname==GL_EYE_PLANE) {
 568             params[0] = (GLint) texUnit->EyePlaneR[0];
 569             params[1] = (GLint) texUnit->EyePlaneR[1];
 570             params[2] = (GLint) texUnit->EyePlaneR[2];
 571             params[3] = (GLint) texUnit->EyePlaneR[3];
 572          }
 573          else {
 574             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 575             return;
 576          }
 577          break;
 578       case GL_Q:
 579          if (pname==GL_TEXTURE_GEN_MODE) {
 580             params[0] = texUnit->GenModeQ;
 581          }
 582          else if (pname==GL_OBJECT_PLANE) {
 583             params[0] = (GLint) texUnit->ObjectPlaneQ[0];
 584             params[1] = (GLint) texUnit->ObjectPlaneQ[1];
 585             params[2] = (GLint) texUnit->ObjectPlaneQ[2];
 586             params[3] = (GLint) texUnit->ObjectPlaneQ[3];
 587          }
 588          else if (pname==GL_EYE_PLANE) {
 589             params[0] = (GLint) texUnit->EyePlaneQ[0];
 590             params[1] = (GLint) texUnit->EyePlaneQ[1];
 591             params[2] = (GLint) texUnit->EyePlaneQ[2];
 592             params[3] = (GLint) texUnit->EyePlaneQ[3];
 593          }
 594          else {
 595             _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 596             return;
 597          }
 598          break;
 599       default:
 600          _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
 601          return;
 602    }
 603 }
 604
 605