Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/texstate.c

    r2962 r3598  
    1 /* $Id: texstate.c,v 1.2 2000-03-01 18:49:36 jeroen Exp $ */
     1/* $Id: texstate.c,v 1.3 2000-05-23 20:40:56 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    3030#include "all.h"
    3131#else
    32 #ifndef XFree86Server
    33 #include <assert.h>
    34 #include <stdio.h>
    35 #else
    36 #include "GL/xf86glx.h"
    37 #endif
     32#include "glheader.h"
    3833#include "types.h"
    3934#include "context.h"
    … …  
    6762/**********************************************************************/
    6863
    69 
    70 void gl_TexEnvfv( GLcontext *ctx,
    71                   GLenum target, GLenum pname, const GLfloat *param )
    72 {
     64void
     65_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
     66{
     67   GET_CURRENT_CONTEXT(ctx);
    7368   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    7469
    7570   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexEnv");
    7671
    77    if (target!=GL_TEXTURE_ENV) {
     72   if (target==GL_TEXTURE_ENV) {
     73
     74      if (pname==GL_TEXTURE_ENV_MODE) {
     75         GLenum mode = (GLenum) (GLint) *param;
     76         switch (mode) {
     77         case GL_ADD:
     78            if (!ctx->Extensions.HaveTextureEnvAdd) {
     79               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(param)");
     80               return;
     81            }
     82            /* FALL-THROUGH */
     83         case GL_MODULATE:
     84         case GL_BLEND:
     85         case GL_DECAL:
     86         case GL_REPLACE:
     87            /* A small optimization for drivers */
     88            if (texUnit->EnvMode == mode)
     89               return;
     90
     91            if (MESA_VERBOSE & (VERBOSE_STATE|VERBOSE_TEXTURE))
     92               fprintf(stderr, "glTexEnv: old mode %s, new mode %s\n",
     93                       gl_lookup_enum_by_nr(texUnit->EnvMode),
     94                       gl_lookup_enum_by_nr(mode));
     95
     96            texUnit->EnvMode = mode;
     97            ctx->NewState |= NEW_TEXTURE_ENV;
     98            break;
     99         default:
     100            gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
     101            return;
     102         }
     103      }
     104      else if (pname==GL_TEXTURE_ENV_COLOR) {
     105         texUnit->EnvColor[0] = CLAMP( param[0], 0.0F, 1.0F );
     106         texUnit->EnvColor[1] = CLAMP( param[1], 0.0F, 1.0F );
     107         texUnit->EnvColor[2] = CLAMP( param[2], 0.0F, 1.0F );
     108         texUnit->EnvColor[3] = CLAMP( param[3], 0.0F, 1.0F );
     109      }
     110      else {
     111         gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
     112         return;
     113      }
     114
     115   }
     116   else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
     117
     118      if (!ctx->Extensions.HaveTextureLodBias) {
     119         gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
     120         return;
     121      }
     122
     123      if (pname==GL_TEXTURE_LOD_BIAS_EXT) {
     124         texUnit->LodBias = param[0];
     125      }
     126      else {
     127         gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
     128         return;
     129      }
     130
     131   }
     132   else {
    78133      gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
    79134      return;
    … …  
    82137   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
    83138      fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
    84               gl_lookup_enum_by_nr(target),
    85               gl_lookup_enum_by_nr(pname),
    86               *param,
    87               gl_lookup_enum_by_nr((GLenum) (GLint) *param));
    88 
    89 
    90    if (pname==GL_TEXTURE_ENV_MODE) {
    91       GLenum mode = (GLenum) (GLint) *param;
    92       switch (mode) {
    93          case GL_MODULATE:
    94          case GL_BLEND:
    95          case GL_DECAL:
    96          case GL_REPLACE:
    97             if (texUnit->EnvMode == mode)
    98                return;  /* no change */
    99 
    100             if (MESA_VERBOSE & (VERBOSE_STATE|VERBOSE_TEXTURE))
    101                fprintf(stderr, "glTexEnv: old mode %s, new mode %s\n",
    102                        gl_lookup_enum_by_nr(texUnit->EnvMode),
    103                        gl_lookup_enum_by_nr(mode));
    104 
    105             texUnit->EnvMode = mode;
    106             ctx->NewState |= NEW_TEXTURE_ENV;
    107             break;
    108          default:
    109             gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
    110             return;
    111       }
    112    }
    113    else if (pname==GL_TEXTURE_ENV_COLOR) {
    114       texUnit->EnvColor[0] = CLAMP( param[0], 0.0F, 1.0F );
    115       texUnit->EnvColor[1] = CLAMP( param[1], 0.0F, 1.0F );
    116       texUnit->EnvColor[2] = CLAMP( param[2], 0.0F, 1.0F );
    117       texUnit->EnvColor[3] = CLAMP( param[3], 0.0F, 1.0F );
    118    }
    119    else {
    120       gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
    121       return;
    122    }
     139              gl_lookup_enum_by_nr(target),
     140              gl_lookup_enum_by_nr(pname),
     141              *param,
     142              gl_lookup_enum_by_nr((GLenum) (GLint) *param));
    123143
    124144   /* Tell device driver about the new texture environment */
    125145   if (ctx->Driver.TexEnv) {
    126       (*ctx->Driver.TexEnv)( ctx, pname, param );
    127    }
    128 }
    129 
    130 
    131 
    132 
    133 
    134 void gl_GetTexEnvfv( GLcontext *ctx,
    135                      GLenum target, GLenum pname, GLfloat *params )
    136 {
     146      (*ctx->Driver.TexEnv)( ctx, target, pname, param );
     147   }
     148
     149}
     150
     151
     152void
     153_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
     154{
     155   _mesa_TexEnvfv( target, pname, &param );
     156}
     157
     158
     159
     160void
     161_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
     162{
     163   GLfloat p[4];
     164   p[0] = (GLfloat) param;
     165   p[1] = p[2] = p[3] = 0.0;
     166   _mesa_TexEnvfv( target, pname, p );
     167}
     168
     169
     170void
     171_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
     172{
     173   GLfloat p[4];
     174   p[0] = INT_TO_FLOAT( param[0] );
     175   p[1] = INT_TO_FLOAT( param[1] );
     176   p[2] = INT_TO_FLOAT( param[2] );
     177   p[3] = INT_TO_FLOAT( param[3] );
     178   _mesa_TexEnvfv( target, pname, p );
     179}
     180
     181
     182void
     183_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
     184{
     185   GET_CURRENT_CONTEXT(ctx);
    137186   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
     187
     188   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnvfv");
     189
    138190   if (target!=GL_TEXTURE_ENV) {
    139191      gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
    … …  
    143195      case GL_TEXTURE_ENV_MODE:
    144196         *params = ENUM_TO_FLOAT(texUnit->EnvMode);
    145         break;
     197        break;
    146198      case GL_TEXTURE_ENV_COLOR:
    147         COPY_4FV( params, texUnit->EnvColor );
    148         break;
     199        COPY_4FV( params, texUnit->EnvColor );
     200        break;
    149201      default:
    150202         gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
    … …  
    153205
    154206
    155 void gl_GetTexEnviv( GLcontext *ctx,
    156                      GLenum target, GLenum pname, GLint *params )
    157 {
     207void
     208_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
     209{
     210   GET_CURRENT_CONTEXT(ctx);
    158211   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
     212
     213   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnviv");
     214
    159215   if (target!=GL_TEXTURE_ENV) {
    160216      gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
    … …  
    164220      case GL_TEXTURE_ENV_MODE:
    165221         *params = (GLint) texUnit->EnvMode;
    166         break;
     222        break;
    167223      case GL_TEXTURE_ENV_COLOR:
    168         params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
    169         params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
    170         params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
    171         params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
    172         break;
     224        params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
     225        params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
     226        params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
     227        params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
     228        break;
    173229      default:
    174230         gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
    … …  
    184240
    185241
    186 void gl_TexParameterfv( GLcontext *ctx,
    187                         GLenum target, GLenum pname, const GLfloat *params )
    188 {
     242void
     243_mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
     244{
     245   _mesa_TexParameterfv(target, pname, &param);
     246}
     247
     248
     249void
     250_mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
     251{
     252   GET_CURRENT_CONTEXT(ctx);
    189253   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    190254   GLenum eparam = (GLenum) (GLint) params[0];
    191255   struct gl_texture_object *texObj;
    192256
     257   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexParameterfv");
     258
    193259   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
    194260      fprintf(stderr, "texPARAM %s %s %d...\n",
    195               gl_lookup_enum_by_nr(target),
    196               gl_lookup_enum_by_nr(pname),
    197               eparam);
     261              gl_lookup_enum_by_nr(target),
     262              gl_lookup_enum_by_nr(pname),
     263              eparam);
    198264
    199265
    … …  
    331397
    332398
    333 
    334 void gl_GetTexLevelParameterfv( GLcontext *ctx, GLenum target, GLint level,
    335                                 GLenum pname, GLfloat *params )
     399void
     400_mesa_TexParameteri( GLenum target, GLenum pname, const GLint param )
     401{
     402   GLfloat fparam[4];
     403   fparam[0] = (GLfloat) param;
     404   fparam[1] = fparam[2] = fparam[3] = 0.0;
     405   _mesa_TexParameterfv(target, pname, fparam);
     406}
     407
     408void
     409_mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
     410{
     411   GLfloat fparam[4];
     412   fparam[0] = (GLfloat) params[0];
     413   fparam[1] = fparam[2] = fparam[3] = 0.0;
     414   _mesa_TexParameterfv(target, pname, fparam);
     415}
     416
     417
     418void
     419_mesa_GetTexLevelParameterfv( GLenum target, GLint level,
     420                              GLenum pname, GLfloat *params )
    336421{
    337422   GLint iparam;
    338    gl_GetTexLevelParameteriv( ctx, target, level, pname, &iparam );
     423   _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
    339424   *params = (GLfloat) iparam;
    340425}
    … …  
    342427
    343428
    344 void gl_GetTexLevelParameteriv( GLcontext *ctx, GLenum target, GLint level,
    345                                 GLenum pname, GLint *params )
    346 {
     429void
     430_mesa_GetTexLevelParameteriv( GLenum target, GLint level,
     431                              GLenum pname, GLint *params )
     432{
     433   GET_CURRENT_CONTEXT(ctx);
    347434   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    348435   const struct gl_texture_image *img = NULL;
    349436   GLuint dimensions;
     437
     438   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexLevelParameter");
    350439
    351440   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
    … …  
    380469         break;
    381470      default:
    382         gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
     471        gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
    383472         return;
    384473   }
    … …  
    449538
    450539
    451 
    452 void gl_GetTexParameterfv( GLcontext *ctx,
    453                            GLenum target, GLenum pname, GLfloat *params )
    454 {
     540void
     541_mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
     542{
     543   GET_CURRENT_CONTEXT(ctx);
    455544   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    456545   struct gl_texture_object *obj;
     546
     547   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameterfv");
    457548
    458549   switch (target) {
    … …  
    473564   switch (pname) {
    474565      case GL_TEXTURE_MAG_FILTER:
    475         *params = ENUM_TO_FLOAT(obj->MagFilter);
    476         break;
     566        *params = ENUM_TO_FLOAT(obj->MagFilter);
     567        break;
    477568      case GL_TEXTURE_MIN_FILTER:
    478569         *params = ENUM_TO_FLOAT(obj->MinFilter);
    … …  
    517608
    518609
    519 void gl_GetTexParameteriv( GLcontext *ctx,
    520                            GLenum target, GLenum pname, GLint *params )
    521 {
     610void
     611_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
     612{
     613   GET_CURRENT_CONTEXT(ctx);
    522614   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    523615   struct gl_texture_object *obj;
     616
     617   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameteriv");
    524618
    525619   switch (target) {
    … …  
    534628         break;
    535629      default:
    536          gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
     630         gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
    537631         return;
    538632   }
    … …  
    598692
    599693
    600 void gl_TexGenfv( GLcontext *ctx,
    601                   GLenum coord, GLenum pname, const GLfloat *params )
    602 {
     694void
     695_mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
     696{
     697   GET_CURRENT_CONTEXT(ctx);
    603698   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
    604699   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
    … …  
    607702   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
    608703      fprintf(stderr, "texGEN %s %s %x...\n",
    609               gl_lookup_enum_by_nr(coord),
    610               gl_lookup_enum_by_nr(pname),
    611               *(int *)params);
    612 
    613    switch( coord ) {
     704              gl_lookup_enum_by_nr(coord),
     705              gl_lookup_enum_by_nr(pname),
     706              *(int *)params);
     707
     708   switch (coord) {
    614709      case GL_S:
    615710         if (pname==GL_TEXTURE_GEN_MODE) {
    616             GLenum mode = (GLenum) (GLint) *params;
    617             switch (mode) {
    618             case GL_OBJECT_LINEAR:
    619                texUnit->GenModeS = mode;
    620                texUnit->GenBitS = TEXGEN_OBJ_LINEAR;
    621                break;
    622             case GL_EYE_LINEAR:
    623                texUnit->GenModeS = mode;
    624                texUnit->GenBitS = TEXGEN_EYE_LINEAR;
    625                break;
    626             case GL_REFLECTION_MAP_NV:
    627                texUnit->GenModeS = mode;
    628                texUnit->GenBitS = TEXGEN_REFLECTION_MAP_NV;
    629                break;
    630             case GL_NORMAL_MAP_NV:
    631                texUnit->GenModeS = mode;
    632                texUnit->GenBitS = TEXGEN_NORMAL_MAP_NV;
    633                break;
    634             case GL_SPHERE_MAP:
    635                texUnit->GenModeS = mode;
    636                texUnit->GenBitS = TEXGEN_SPHERE_MAP;
    637                break;
    638             default:
    639                gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
    640                return;
    641             }
    642         }
    643         else if (pname==GL_OBJECT_PLANE) {
    644             texUnit->ObjectPlaneS[0] = params[0];
    645             texUnit->ObjectPlaneS[1] = params[1];
    646             texUnit->ObjectPlaneS[2] = params[2];
    647             texUnit->ObjectPlaneS[3] = params[3];
    648         }
    649         else if (pname==GL_EYE_PLANE) {
     711            GLenum mode = (GLenum) (GLint) *params;
     712            switch (mode) {
     713            case GL_OBJECT_LINEAR:
     714               texUnit->GenModeS = mode;
     715               texUnit->GenBitS = TEXGEN_OBJ_LINEAR;
     716               break;
     717            case GL_EYE_LINEAR:
     718               texUnit->GenModeS = mode;
     719               texUnit->GenBitS = TEXGEN_EYE_LINEAR;
     720               break;
     721            case GL_REFLECTION_MAP_NV:
     722               texUnit->GenModeS = mode;
     723               texUnit->GenBitS = TEXGEN_REFLECTION_MAP_NV;
     724               break;
     725            case GL_NORMAL_MAP_NV:
     726               texUnit->GenModeS = mode;
     727               texUnit->GenBitS = TEXGEN_NORMAL_MAP_NV;
     728               break;
     729            case GL_SPHERE_MAP:
     730               texUnit->GenModeS = mode;
     731               texUnit->GenBitS = TEXGEN_SPHERE_MAP;
     732               break;
     733            default:
     734               gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
     735               return;
     736            }
     737        }
     738        else if (pname==GL_OBJECT_PLANE) {
     739            texUnit->ObjectPlaneS[0] = params[0];
     740            texUnit->ObjectPlaneS[1] = params[1];
     741            texUnit->ObjectPlaneS[2] = params[2];
     742            texUnit->ObjectPlaneS[3] = params[3];
     743        }
     744        else if (pname==GL_EYE_PLANE) {
    650745            /* Transform plane equation by the inverse modelview matrix */
    651746            if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
    … …  
    654749            gl_transform_vector( texUnit->EyePlaneS, params,
    655750                                 ctx->ModelView.inv );
    656         }
    657         else {
    658             gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
    659             return;
    660         }
    661         break;
     751        }
     752        else {
     753            gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
     754            return;
     755        }
     756        break;
    662757      case GL_T:
    663758         if (pname==GL_TEXTURE_GEN_MODE) {
    664             GLenum mode = (GLenum) (GLint) *params;
    665             switch(mode) {
    666             case GL_OBJECT_LINEAR:
    667                texUnit->GenModeT = GL_OBJECT_LINEAR;
    668                texUnit->GenBitT = TEXGEN_OBJ_LINEAR;
    669                break;
    670             case GL_EYE_LINEAR:
    671                texUnit->GenModeT = GL_EYE_LINEAR;
    672                texUnit->GenBitT = TEXGEN_EYE_LINEAR;
    673                break;
    674             case GL_REFLECTION_MAP_NV:
    675                texUnit->GenModeT = GL_REFLECTION_MAP_NV;
    676                texUnit->GenBitT = TEXGEN_REFLECTION_MAP_NV;
    677                break;
    678             case GL_NORMAL_MAP_NV:
    679                texUnit->GenModeT = GL_NORMAL_MAP_NV;
    680                texUnit->GenBitT = TEXGEN_NORMAL_MAP_NV;
    681                break;
    682             case GL_SPHERE_MAP:
    683                texUnit->GenModeT = GL_SPHERE_MAP;
    684                texUnit->GenBitT = TEXGEN_SPHERE_MAP;
    685                break;
    686             default:
    687                gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
    688                return;
    689             }
    690         }
    691         else if (pname==GL_OBJECT_PLANE) {
    692             texUnit->ObjectPlaneT[0] = params[0];
    693             texUnit->ObjectPlaneT[1] = params[1];
    694             texUnit->ObjectPlaneT[2] = params[2];
    695             texUnit->ObjectPlaneT[3] = params[3];
    696         }
    697         else if (pname==GL_EYE_PLANE) {
     759            GLenum mode = (GLenum) (GLint) *params;
     760            switch(mode) {
     761            case GL_OBJECT_LINEAR:
     762               texUnit->GenModeT = GL_OBJECT_LINEAR;
     763               texUnit->GenBitT = TEXGEN_OBJ_LINEAR;
     764               break;
     765            case GL_EYE_LINEAR:
     766               texUnit->GenModeT = GL_EYE_LINEAR;
     767               texUnit->GenBitT = TEXGEN_EYE_LINEAR;
     768               break;
     769            case GL_REFLECTION_MAP_NV:
     770               texUnit->GenModeT = GL_REFLECTION_MAP_NV;
     771               texUnit->GenBitT = TEXGEN_REFLECTION_MAP_NV;
     772               break;
     773            case GL_NORMAL_MAP_NV:
     774               texUnit->GenModeT = GL_NORMAL_MAP_NV;
     775               texUnit->GenBitT = TEXGEN_NORMAL_MAP_NV;
     776               break;
     777            case GL_SPHERE_MAP:
     778               texUnit->GenModeT = GL_SPHERE_MAP;
     779               texUnit->GenBitT = TEXGEN_SPHERE_MAP;
     780               break;
     781            default:
     782               gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
     783               return;
     784            }
     785        }
     786        else if (pname==GL_OBJECT_PLANE) {
     787            texUnit->ObjectPlaneT[0] = params[0];
     788            texUnit->ObjectPlaneT[1] = params[1];
     789            texUnit->ObjectPlaneT[2] = params[2];
     790            texUnit->ObjectPlaneT[3] = params[3];
     791        }
     792        else if (pname==GL_EYE_PLANE) {
    698793            /* Transform plane equation by the inverse modelview matrix */
    699794            if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
    … …  
    702797            gl_transform_vector( texUnit->EyePlaneT, params,
    703798                                 ctx->ModelView.inv );
    704         }
    705         else {
    706             gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
    707             return;
    708         }
    709         break;
     799        }
     800        else {
     801            gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
     802            return;
     803        }
     804        break;
    710805      case GL_R:
    711806         if (pname==GL_TEXTURE_GEN_MODE) {
    712             GLenum mode = (GLenum) (GLint) *params;
    713             switch (mode) {
    714             case GL_OBJECT_LINEAR:
    715                texUnit->GenModeR = GL_OBJECT_LINEAR;
    716                texUnit->GenBitR = TEXGEN_OBJ_LINEAR;
    717                break;
    718             case GL_REFLECTION_MAP_NV:
    719                texUnit->GenModeR = GL_REFLECTION_MAP_NV;
    720                texUnit->GenBitR = TEXGEN_REFLECTION_MAP_NV;
    721                break;
    722             case GL_NORMAL_MAP_NV:
    723                texUnit->GenModeR = GL_NORMAL_MAP_NV;
    724                texUnit->GenBitR = TEXGEN_NORMAL_MAP_NV;
    725                break;
    726             case GL_EYE_LINEAR:
    727                texUnit->GenModeR = GL_EYE_LINEAR;
    728                texUnit->GenBitR = TEXGEN_EYE_LINEAR;
    729                break;
    730             default:
    731                gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
    732                return;
    733             }
    734         }
    735         else if (pname==GL_OBJECT_PLANE) {
    736             texUnit->ObjectPlaneR[0] = params[0];
    737             texUnit->ObjectPlaneR[1] = params[1];
    738             texUnit->ObjectPlaneR[2] = params[2];
    739             texUnit->ObjectPlaneR[3] = params[3];
    740         }
    741         else if (pname==GL_EYE_PLANE) {
     807            GLenum mode = (GLenum) (GLint) *params;
     808            switch (mode) {
     809            case GL_OBJECT_LINEAR:
     810               texUnit->GenModeR = GL_OBJECT_LINEAR;
     811               texUnit->GenBitR = TEXGEN_OBJ_LINEAR;
     812               break;
     813            case GL_REFLECTION_MAP_NV:
     814               texUnit->GenModeR = GL_REFLECTION_MAP_NV;
     815               texUnit->GenBitR = TEXGEN_REFLECTION_MAP_NV;
     816               break;
     817            case GL_NORMAL_MAP_NV:
     818               texUnit->GenModeR = GL_NORMAL_MAP_NV;
     819               texUnit->GenBitR = TEXGEN_NORMAL_MAP_NV;
     820               break;
     821            case GL_EYE_LINEAR:
     822               texUnit->GenModeR = GL_EYE_LINEAR;
     823               texUnit->GenBitR = TEXGEN_EYE_LINEAR;
     824               break;
     825            default:
     826               gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
     827               return;
     828            }
     829        }
     830        else if (pname==GL_OBJECT_PLANE) {
     831            texUnit->ObjectPlaneR[0] = params[0];
     832            texUnit->ObjectPlaneR[1] = params[1];
     833            texUnit->ObjectPlaneR[2] = params[2];
     834            texUnit->ObjectPlaneR[3] = params[3];
     835        }
     836        else if (pname==GL_EYE_PLANE) {
    742837            /* Transform plane equation by the inverse modelview matrix */
    743838            if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
    … …  
    746841            gl_transform_vector( texUnit->EyePlaneR, params,
    747842                                 ctx->ModelView.inv );
    748         }
    749         else {
    750             gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
    751             return;
    752         }
    753         break;
     843        }
     844        else {
     845            gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
     846            return;
     847        }
     848        break;
    754849      case GL_Q:
    755850         if (pname==GL_TEXTURE_GEN_MODE) {
    756             GLenum mode = (GLenum) (GLint) *params;
    757             switch (mode) {
    758             case GL_OBJECT_LINEAR:
    759                texUnit->GenModeQ = GL_OBJECT_LINEAR;
    760                texUnit->GenBitQ = TEXGEN_OBJ_LINEAR;
    761                break;
    762             case GL_EYE_LINEAR:
    763                texUnit->GenModeQ = GL_EYE_LINEAR;
    764                texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
    765                break;
    766             default:
    767                gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
    768                return;
    769             }
    770         }
    771         else if (pname==GL_OBJECT_PLANE) {
    772             texUnit->ObjectPlaneQ[0] = params[0];
    773             texUnit->ObjectPlaneQ[1] = params[1];
    774             texUnit->ObjectPlaneQ[2] = params[2];
    775             texUnit->ObjectPlaneQ[3] = params[3];
    776         }
    777         else if (pname==GL_EYE_PLANE) {
     851            GLenum mode = (GLenum) (GLint) *params;
     852            switch (mode) {
     853            case GL_OBJECT_LINEAR:
     854               texUnit->GenModeQ = GL_OBJECT_LINEAR;
     855               texUnit->GenBitQ = TEXGEN_OBJ_LINEAR;
     856               break;
     857            case GL_EYE_LINEAR:
     858               texUnit->GenModeQ = GL_EYE_LINEAR;
     859               texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
     860               break;
     861            default:
     862               gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
     863               return;
     864            }
     865        }
     866        else if (pname==GL_OBJECT_PLANE) {
     867            texUnit->ObjectPlaneQ[0] = params[0];
     868            texUnit->ObjectPlaneQ[1] = params[1];
     869            texUnit->ObjectPlaneQ[2] = params[2];
     870            texUnit->ObjectPlaneQ[3] = params[3];
     871        }
     872        else if (pname==GL_EYE_PLANE) {
    778873            /* Transform plane equation by the inverse modelview matrix */
    779874            if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
    … …  
    782877            gl_transform_vector( texUnit->EyePlaneQ, params,
    783878                                 ctx->ModelView.inv );
    784         }
    785         else {
    786             gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
    787             return;
    788         }
    789         break;
     879        }
     880        else {
     881            gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
     882            return;
     883        }
     884        break;
    790885      default:
    791886         gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
    792         return;
     887        return;
    793888   }
    794889
    … …  
    797892
    798893
    799 
    800 void gl_GetTexGendv( GLcontext *ctx,
    801                      GLenum coord, GLenum pname, GLdouble *params )
    802 {
     894void
     895_mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
     896{
     897   GLfloat p[4];
     898   p[0] = params[0];
     899   p[1] = params[1];
     900   p[2] = params[2];
     901   p[3] = params[3];
     902   _mesa_TexGenfv(coord, pname, p);
     903}
     904
     905
     906void
     907_mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
     908{
     909   GLfloat p = (GLfloat) param;
     910   _mesa_TexGenfv( coord, pname, &p );
     911}
     912
     913
     914void
     915_mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
     916{
     917   GLfloat p[4];
     918   p[0] = params[0];
     919   p[1] = params[1];
     920   p[2] = params[2];
     921   p[3] = params[3];
     922   _mesa_TexGenfv( coord, pname, p );
     923}
     924
     925
     926void
     927_mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
     928{
     929   _mesa_TexGenfv(coord, pname, &param);
     930}
     931
     932
     933void
     934_mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
     935{
     936   _mesa_TexGeniv( coord, pname, &param );
     937}
     938
     939
     940
     941void
     942_mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
     943{
     944   GET_CURRENT_CONTEXT(ctx);
    803945   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
    804946   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
    … …  
    810952         if (pname==GL_TEXTURE_GEN_MODE) {
    811953            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
    812         }
    813         else if (pname==GL_OBJECT_PLANE) {
     954        }
     955        else if (pname==GL_OBJECT_PLANE) {
    814956            COPY_4V( params, texUnit->ObjectPlaneS );
    815         }
    816         else if (pname==GL_EYE_PLANE) {
     957        }
     958        else if (pname==GL_EYE_PLANE) {
    817959            COPY_4V( params, texUnit->EyePlaneS );
    818         }
    819         else {
    820             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
    821             return;
    822         }
    823         break;
     960        }
     961        else {
     962            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
     963            return;
     964        }
     965        break;
    824966      case GL_T:
    825967         if (pname==GL_TEXTURE_GEN_MODE) {
    826968            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
    827         }
    828         else if (pname==GL_OBJECT_PLANE) {
     969        }
     970        else if (pname==GL_OBJECT_PLANE) {
    829971            COPY_4V( params, texUnit->ObjectPlaneT );
    830         }
    831         else if (pname==GL_EYE_PLANE) {
     972        }
     973        else if (pname==GL_EYE_PLANE) {
    832974            COPY_4V( params, texUnit->EyePlaneT );
    833         }
    834         else {
    835             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
    836             return;
    837         }
    838         break;
     975        }
     976        else {
     977            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
     978            return;
     979        }
     980        break;
    839981      case GL_R:
    840982         if (pname==GL_TEXTURE_GEN_MODE) {
    841983            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
    842         }
    843         else if (pname==GL_OBJECT_PLANE) {
     984        }
     985        else if (pname==GL_OBJECT_PLANE) {
    844986            COPY_4V( params, texUnit->ObjectPlaneR );
    845         }
    846         else if (pname==GL_EYE_PLANE) {
     987        }
     988        else if (pname==GL_EYE_PLANE) {
    847989            COPY_4V( params, texUnit->EyePlaneR );
    848         }
    849         else {
    850             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
    851             return;
    852         }
    853         break;
     990        }
     991        else {
     992            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
     993            return;
     994        }
     995        break;
    854996      case GL_Q:
    855997         if (pname==GL_TEXTURE_GEN_MODE) {
    856998            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
    857         }
    858         else if (pname==GL_OBJECT_PLANE) {
     999        }
     1000        else if (pname==GL_OBJECT_PLANE) {
    8591001            COPY_4V( params, texUnit->ObjectPlaneQ );
    860         }
    861         else if (pname==GL_EYE_PLANE) {
     1002        }
     1003        else if (pname==GL_EYE_PLANE) {
    8621004            COPY_4V( params, texUnit->EyePlaneQ );
    863         }
    864         else {
    865             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
    866             return;
    867         }
    868         break;
     1005        }
     1006        else {
     1007            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
     1008            return;
     1009        }
     1010        break;
    8691011      default:
    8701012         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
    871          return;
    872    }
    873 }
    874 
    875 
    876 
    877 void gl_GetTexGenfv( GLcontext *ctx,
    878                      GLenum coord, GLenum pname, GLfloat *params )
    879 {
     1013         return;
     1014   }
     1015}
     1016
     1017
     1018
     1019void
     1020_mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
     1021{
     1022   GET_CURRENT_CONTEXT(ctx);
    8801023   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
    8811024   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
    … …  
    8871030         if (pname==GL_TEXTURE_GEN_MODE) {
    8881031            params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
    889         }
    890         else if (pname==GL_OBJECT_PLANE) {
     1032        }
     1033        else if (pname==GL_OBJECT_PLANE) {
    8911034            COPY_4V( params, texUnit->ObjectPlaneS );
    892         }
    893         else if (pname==GL_EYE_PLANE) {
     1035        }
     1036        else if (pname==GL_EYE_PLANE) {
    8941037            COPY_4V( params, texUnit->EyePlaneS );
    895         }
    896         else {
    897             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
    898             return;
    899         }
    900         break;
     1038        }
     1039        else {
     1040            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
     1041            return;
     1042        }
     1043        break;
    9011044      case GL_T:
    9021045         if (pname==GL_TEXTURE_GEN_MODE) {
    9031046            params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
    904         }
    905         else if (pname==GL_OBJECT_PLANE) {
     1047        }
     1048        else if (pname==GL_OBJECT_PLANE) {
    9061049            COPY_4V( params, texUnit->ObjectPlaneT );
    907         }
    908         else if (pname==GL_EYE_PLANE) {
     1050        }
     1051        else if (pname==GL_EYE_PLANE) {
    9091052            COPY_4V( params, texUnit->EyePlaneT );
    910         }
    911         else {
    912             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
    913             return;
    914         }
    915         break;
     1053        }
     1054        else {
     1055            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
     1056            return;
     1057        }
     1058        break;
    9161059      case GL_R:
    9171060         if (pname==GL_TEXTURE_GEN_MODE) {
    9181061            params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
    919         }
    920         else if (pname==GL_OBJECT_PLANE) {
     1062        }
     1063        else if (pname==GL_OBJECT_PLANE) {
    9211064            COPY_4V( params, texUnit->ObjectPlaneR );
    922         }
    923         else if (pname==GL_EYE_PLANE) {
     1065        }
     1066        else if (pname==GL_EYE_PLANE) {
    9241067            COPY_4V( params, texUnit->EyePlaneR );
    925         }
    926         else {
    927             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
    928             return;
    929         }
    930         break;
     1068        }
     1069        else {
     1070            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
     1071            return;
     1072        }
     1073        break;
    9311074      case GL_Q:
    9321075         if (pname==GL_TEXTURE_GEN_MODE) {
    9331076            params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
    934         }
    935         else if (pname==GL_OBJECT_PLANE) {
     1077        }
     1078        else if (pname==GL_OBJECT_PLANE) {
    9361079            COPY_4V( params, texUnit->ObjectPlaneQ );
    937         }
    938         else if (pname==GL_EYE_PLANE) {
     1080        }
     1081        else if (pname==GL_EYE_PLANE) {
    9391082            COPY_4V( params, texUnit->EyePlaneQ );
    940         }
    941         else {
    942             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
    943             return;
    944         }
    945         break;
     1083        }
     1084        else {
     1085            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
     1086            return;
     1087        }
     1088        break;
    9461089      default:
    9471090         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
    948          return;
    949    }
    950 }
    951 
    952 
    953 
    954 void gl_GetTexGeniv( GLcontext *ctx,
    955                      GLenum coord, GLenum pname, GLint *params )
    956 {
     1091         return;
     1092   }
     1093}
     1094
     1095
     1096
     1097void
     1098_mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
     1099{
     1100   GET_CURRENT_CONTEXT(ctx);
    9571101   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
    9581102   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
    … …  
    9641108         if (pname==GL_TEXTURE_GEN_MODE) {
    9651109            params[0] = texUnit->GenModeS;
    966         }
    967         else if (pname==GL_OBJECT_PLANE) {
     1110        }
     1111        else if (pname==GL_OBJECT_PLANE) {
    9681112            params[0] = (GLint) texUnit->ObjectPlaneS[0];
    9691113            params[1] = (GLint) texUnit->ObjectPlaneS[1];
    9701114            params[2] = (GLint) texUnit->ObjectPlaneS[2];
    9711115            params[3] = (GLint) texUnit->ObjectPlaneS[3];
    972         }
    973         else if (pname==GL_EYE_PLANE) {
     1116        }
     1117        else if (pname==GL_EYE_PLANE) {
    9741118            params[0] = (GLint) texUnit->EyePlaneS[0];
    9751119            params[1] = (GLint) texUnit->EyePlaneS[1];
    9761120            params[2] = (GLint) texUnit->EyePlaneS[2];
    9771121            params[3] = (GLint) texUnit->EyePlaneS[3];
    978         }
    979         else {
    980             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
    981             return;
    982         }
    983         break;
     1122        }
     1123        else {
     1124            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
     1125            return;
     1126        }
     1127        break;
    9841128      case GL_T:
    9851129         if (pname==GL_TEXTURE_GEN_MODE) {
    986             params[0] = (GLint) texUnit->GenModeT;
    987         }
    988         else if (pname==GL_OBJECT_PLANE) {
     1130            params[0] = texUnit->GenModeT;
     1131        }
     1132        else if (pname==GL_OBJECT_PLANE) {
    9891133            params[0] = (GLint) texUnit->ObjectPlaneT[0];
    9901134            params[1] = (GLint) texUnit->ObjectPlaneT[1];
    9911135            params[2] = (GLint) texUnit->ObjectPlaneT[2];
    9921136            params[3] = (GLint) texUnit->ObjectPlaneT[3];
    993         }
    994         else if (pname==GL_EYE_PLANE) {
     1137        }
     1138        else if (pname==GL_EYE_PLANE) {
    9951139            params[0] = (GLint) texUnit->EyePlaneT[0];
    9961140            params[1] = (GLint) texUnit->EyePlaneT[1];
    9971141            params[2] = (GLint) texUnit->EyePlaneT[2];
    9981142            params[3] = (GLint) texUnit->EyePlaneT[3];
    999         }
    1000         else {
    1001             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
    1002             return;
    1003         }
    1004         break;
     1143        }
     1144        else {
     1145            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
     1146            return;
     1147        }
     1148        break;
    10051149      case GL_R:
    10061150         if (pname==GL_TEXTURE_GEN_MODE) {
    1007             params[0] = (GLint) texUnit->GenModeR;
    1008         }
    1009         else if (pname==GL_OBJECT_PLANE) {
     1151            params[0] = texUnit->GenModeR;
     1152        }
     1153        else if (pname==GL_OBJECT_PLANE) {
    10101154            params[0] = (GLint) texUnit->ObjectPlaneR[0];
    10111155            params[1] = (GLint) texUnit->ObjectPlaneR[1];
    10121156            params[2] = (GLint) texUnit->ObjectPlaneR[2];
    10131157            params[3] = (GLint) texUnit->ObjectPlaneR[3];
    1014         }
    1015         else if (pname==GL_EYE_PLANE) {
     1158        }
     1159        else if (pname==GL_EYE_PLANE) {
    10161160            params[0] = (GLint) texUnit->EyePlaneR[0];
    10171161            params[1] = (GLint) texUnit->EyePlaneR[1];
    10181162            params[2] = (GLint) texUnit->EyePlaneR[2];
    10191163            params[3] = (GLint) texUnit->EyePlaneR[3];
    1020         }
    1021         else {
    1022             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
    1023             return;
    1024         }
    1025         break;
     1164        }
     1165        else {
     1166            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
     1167            return;
     1168        }
     1169        break;
    10261170      case GL_Q:
    10271171         if (pname==GL_TEXTURE_GEN_MODE) {
    1028             params[0] = (GLint) texUnit->GenModeQ;
    1029         }
    1030         else if (pname==GL_OBJECT_PLANE) {
     1172            params[0] = texUnit->GenModeQ;
     1173        }
     1174        else if (pname==GL_OBJECT_PLANE) {
    10311175            params[0] = (GLint) texUnit->ObjectPlaneQ[0];
    10321176            params[1] = (GLint) texUnit->ObjectPlaneQ[1];
    10331177            params[2] = (GLint) texUnit->ObjectPlaneQ[2];
    10341178            params[3] = (GLint) texUnit->ObjectPlaneQ[3];
    1035         }
    1036         else if (pname==GL_EYE_PLANE) {
     1179        }
     1180        else if (pname==GL_EYE_PLANE) {
    10371181            params[0] = (GLint) texUnit->EyePlaneQ[0];
    10381182            params[1] = (GLint) texUnit->EyePlaneQ[1];
    10391183            params[2] = (GLint) texUnit->EyePlaneQ[2];
    10401184            params[3] = (GLint) texUnit->EyePlaneQ[3];
    1041         }
    1042         else {
    1043             gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
    1044             return;
    1045         }
    1046         break;
     1185        }
     1186        else {
     1187            gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
     1188            return;
     1189        }
     1190        break;
    10471191      default:
    10481192         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
    1049         return;
     1193        return;
    10501194   }
    10511195}
    … …  
    10531197
    10541198/* GL_ARB_multitexture */
    1055 void gl_ActiveTexture( GLcontext *ctx, GLenum target )
    1056 {
     1199void
     1200_mesa_ActiveTextureARB( GLenum target )
     1201{
     1202   GET_CURRENT_CONTEXT(ctx);
    10571203   GLint maxUnits = ctx->Const.MaxTextureUnits;
    10581204
    … …  
    10611207   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
    10621208      fprintf(stderr, "glActiveTexture %s\n",
    1063               gl_lookup_enum_by_nr(target));
     1209              gl_lookup_enum_by_nr(target));
    10641210
    10651211   if (target >= GL_TEXTURE0_ARB && target < GL_TEXTURE0_ARB + maxUnits) {
    … …  
    10781224
    10791225/* GL_ARB_multitexture */
    1080 void gl_ClientActiveTexture( GLcontext *ctx, GLenum target )
    1081 {
     1226void
     1227_mesa_ClientActiveTextureARB( GLenum target )
     1228{
     1229   GET_CURRENT_CONTEXT(ctx);
    10821230   GLint maxUnits = ctx->Const.MaxTextureUnits;
    10831231
    … …  
    11551303/*
    11561304 * This is called by gl_update_state() if the NEW_TEXTURING bit in
    1157  * ctx->NewState is unit.
     1305 * ctx->NewState is set.
    11581306 */
    11591307void gl_update_dirty_texobjs( GLcontext *ctx )
Note: See TracChangeset for help on using the changeset viewer.