/**
* Update the ctx->Color._ClampFragmentColor field
*/
void
_mesa_update_clamp_fragment_color(struct gl_context *ctx)
{
struct gl_framebuffer *fb = ctx->DrawBuffer;
/* Don't clamp if:
* - there is no colorbuffer
* - all colorbuffers are unsigned normalized, so clamping has no effect
* - there is an integer colorbuffer
*/
if (!fb || !fb->_HasSNormOrFloatColorBuffer || fb->_IntegerColor)
ctx->Color._ClampFragmentColor = GL_FALSE;
else
ctx->Color._ClampFragmentColor = _mesa_get_clamp_fragment_color(ctx);
}
/**
* Update the ctx->Color._ClampFragmentColor field
*/
void
_mesa_update_clamp_fragment_color(struct gl_context *ctx,
const struct gl_framebuffer *drawFb)
{
/* Don't clamp if:
* - there is no colorbuffer
* - all colorbuffers are unsigned normalized, so clamping has no effect
* - there is an integer colorbuffer
*/
if (!drawFb || !drawFb->_HasSNormOrFloatColorBuffer ||
drawFb->_IntegerBuffers)
ctx->Color._ClampFragmentColor = GL_FALSE;
else
ctx->Color._ClampFragmentColor =
_mesa_get_clamp_fragment_color(ctx, drawFb);
}
/**
* Use the list of tokens in the state[] array to find global GL state
* and return it in <value>. Usually, four values are returned in <value>
* but matrix queries may return as many as 16 values.
* This function is used for ARB vertex/fragment programs.
* The program parser will produce the state[] values.
*/
static void
_mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
GLfloat *value)
{
switch (state[0]) {
case STATE_MATERIAL:
{
/* state[1] is either 0=front or 1=back side */
const GLuint face = (GLuint) state[1];
const struct gl_material *mat = &ctx->Light.Material;
ASSERT(face == 0 || face == 1);
/* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
ASSERT(MAT_ATTRIB_FRONT_AMBIENT + 1 == MAT_ATTRIB_BACK_AMBIENT);
/* XXX we could get rid of this switch entirely with a little
* work in arbprogparse.c's parse_state_single_item().
*/
/* state[2] is the material attribute */
switch (state[2]) {
case STATE_AMBIENT:
COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
return;
case STATE_DIFFUSE:
COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
return;
case STATE_SPECULAR:
COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
return;
case STATE_EMISSION:
COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
return;
case STATE_SHININESS:
value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
value[1] = 0.0F;
value[2] = 0.0F;
value[3] = 1.0F;
return;
default:
_mesa_problem(ctx, "Invalid material state in fetch_state");
return;
}
}
case STATE_LIGHT:
{
/* state[1] is the light number */
const GLuint ln = (GLuint) state[1];
/* state[2] is the light attribute */
switch (state[2]) {
case STATE_AMBIENT:
COPY_4V(value, ctx->Light.Light[ln].Ambient);
return;
case STATE_DIFFUSE:
COPY_4V(value, ctx->Light.Light[ln].Diffuse);
return;
case STATE_SPECULAR:
COPY_4V(value, ctx->Light.Light[ln].Specular);
return;
case STATE_POSITION:
COPY_4V(value, ctx->Light.Light[ln].EyePosition);
return;
case STATE_ATTENUATION:
value[0] = ctx->Light.Light[ln].ConstantAttenuation;
value[1] = ctx->Light.Light[ln].LinearAttenuation;
value[2] = ctx->Light.Light[ln].QuadraticAttenuation;
value[3] = ctx->Light.Light[ln].SpotExponent;
return;
case STATE_SPOT_DIRECTION:
COPY_3V(value, ctx->Light.Light[ln].SpotDirection);
value[3] = ctx->Light.Light[ln]._CosCutoff;
return;
case STATE_SPOT_CUTOFF:
value[0] = ctx->Light.Light[ln].SpotCutoff;
return;
case STATE_HALF_VECTOR:
{
static const GLfloat eye_z[] = {0, 0, 1};
GLfloat p[3];
/* Compute infinite half angle vector:
* halfVector = normalize(normalize(lightPos) + (0, 0, 1))
* light.EyePosition.w should be 0 for infinite lights.
*/
COPY_3V(p, ctx->Light.Light[ln].EyePosition);
NORMALIZE_3FV(p);
ADD_3V(value, p, eye_z);
NORMALIZE_3FV(value);
value[3] = 1.0;
}
return;
default:
_mesa_problem(ctx, "Invalid light state in fetch_state");
return;
}
}
case STATE_LIGHTMODEL_AMBIENT:
COPY_4V(value, ctx->Light.Model.Ambient);
return;
case STATE_LIGHTMODEL_SCENECOLOR:
if (state[1] == 0) {
/* front */
GLint i;
for (i = 0; i < 3; i++) {
value[i] = ctx->Light.Model.Ambient[i]
* ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
+ ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
}
value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
}
else {
/* back */
GLint i;
for (i = 0; i < 3; i++) {
value[i] = ctx->Light.Model.Ambient[i]
* ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
+ ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
}
value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
}
return;
case STATE_LIGHTPROD:
{
const GLuint ln = (GLuint) state[1];
const GLuint face = (GLuint) state[2];
GLint i;
ASSERT(face == 0 || face == 1);
switch (state[3]) {
case STATE_AMBIENT:
for (i = 0; i < 3; i++) {
value[i] = ctx->Light.Light[ln].Ambient[i] *
ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
}
/* [3] = material alpha */
value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
return;
case STATE_DIFFUSE:
for (i = 0; i < 3; i++) {
value[i] = ctx->Light.Light[ln].Diffuse[i] *
ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
}
/* [3] = material alpha */
value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
return;
case STATE_SPECULAR:
for (i = 0; i < 3; i++) {
value[i] = ctx->Light.Light[ln].Specular[i] *
ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
}
/* [3] = material alpha */
value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
return;
default:
_mesa_problem(ctx, "Invalid lightprod state in fetch_state");
return;
}
}
case STATE_TEXGEN:
{
/* state[1] is the texture unit */
const GLuint unit = (GLuint) state[1];
/* state[2] is the texgen attribute */
switch (state[2]) {
case STATE_TEXGEN_EYE_S:
COPY_4V(value, ctx->Texture.Unit[unit].GenS.EyePlane);
return;
case STATE_TEXGEN_EYE_T:
COPY_4V(value, ctx->Texture.Unit[unit].GenT.EyePlane);
return;
case STATE_TEXGEN_EYE_R:
COPY_4V(value, ctx->Texture.Unit[unit].GenR.EyePlane);
return;
case STATE_TEXGEN_EYE_Q:
COPY_4V(value, ctx->Texture.Unit[unit].GenQ.EyePlane);
return;
case STATE_TEXGEN_OBJECT_S:
COPY_4V(value, ctx->Texture.Unit[unit].GenS.ObjectPlane);
return;
case STATE_TEXGEN_OBJECT_T:
COPY_4V(value, ctx->Texture.Unit[unit].GenT.ObjectPlane);
return;
case STATE_TEXGEN_OBJECT_R:
COPY_4V(value, ctx->Texture.Unit[unit].GenR.ObjectPlane);
return;
case STATE_TEXGEN_OBJECT_Q:
COPY_4V(value, ctx->Texture.Unit[unit].GenQ.ObjectPlane);
return;
default:
_mesa_problem(ctx, "Invalid texgen state in fetch_state");
return;
}
}
case STATE_TEXENV_COLOR:
{
/* state[1] is the texture unit */
const GLuint unit = (GLuint) state[1];
if (_mesa_get_clamp_fragment_color(ctx))
COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
else
COPY_4V(value, ctx->Texture.Unit[unit].EnvColorUnclamped);
}
return;
case STATE_FOG_COLOR:
if (_mesa_get_clamp_fragment_color(ctx))
COPY_4V(value, ctx->Fog.Color);
else
COPY_4V(value, ctx->Fog.ColorUnclamped);
return;
case STATE_FOG_PARAMS:
value[0] = ctx->Fog.Density;
value[1] = ctx->Fog.Start;
value[2] = ctx->Fog.End;
value[3] = 1.0f / (ctx->Fog.End - ctx->Fog.Start);
return;
case STATE_CLIPPLANE:
{
const GLuint plane = (GLuint) state[1];
COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
}
return;
case STATE_POINT_SIZE:
value[0] = ctx->Point.Size;
value[1] = ctx->Point.MinSize;
value[2] = ctx->Point.MaxSize;
value[3] = ctx->Point.Threshold;
return;
case STATE_POINT_ATTENUATION:
value[0] = ctx->Point.Params[0];
value[1] = ctx->Point.Params[1];
value[2] = ctx->Point.Params[2];
value[3] = 1.0F;
return;
case STATE_MODELVIEW_MATRIX:
case STATE_PROJECTION_MATRIX:
case STATE_MVP_MATRIX:
case STATE_TEXTURE_MATRIX:
case STATE_PROGRAM_MATRIX:
{
/* state[0] = modelview, projection, texture, etc. */
/* state[1] = which texture matrix or program matrix */
/* state[2] = first row to fetch */
/* state[3] = last row to fetch */
/* state[4] = transpose, inverse or invtrans */
const GLmatrix *matrix;
const gl_state_index mat = state[0];
const GLuint index = (GLuint) state[1];
const GLuint firstRow = (GLuint) state[2];
const GLuint lastRow = (GLuint) state[3];
const gl_state_index modifier = state[4];
const GLfloat *m;
GLuint row, i;
ASSERT(firstRow >= 0);
ASSERT(firstRow < 4);
ASSERT(lastRow >= 0);
ASSERT(lastRow < 4);
if (mat == STATE_MODELVIEW_MATRIX) {
matrix = ctx->ModelviewMatrixStack.Top;
}
else if (mat == STATE_PROJECTION_MATRIX) {
matrix = ctx->ProjectionMatrixStack.Top;
}
else if (mat == STATE_MVP_MATRIX) {
matrix = &ctx->_ModelProjectMatrix;
}
else if (mat == STATE_TEXTURE_MATRIX) {
ASSERT(index < Elements(ctx->TextureMatrixStack));
matrix = ctx->TextureMatrixStack[index].Top;
}
else if (mat == STATE_PROGRAM_MATRIX) {
ASSERT(index < Elements(ctx->ProgramMatrixStack));
matrix = ctx->ProgramMatrixStack[index].Top;
}
else {
_mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
return;
}
if (modifier == STATE_MATRIX_INVERSE ||
modifier == STATE_MATRIX_INVTRANS) {
/* Be sure inverse is up to date:
*/
_math_matrix_analyse( (GLmatrix*) matrix );
m = matrix->inv;
}
else {
m = matrix->m;
}
if (modifier == STATE_MATRIX_TRANSPOSE ||
modifier == STATE_MATRIX_INVTRANS) {
for (i = 0, row = firstRow; row <= lastRow; row++) {
value[i++] = m[row * 4 + 0];
value[i++] = m[row * 4 + 1];
value[i++] = m[row * 4 + 2];
value[i++] = m[row * 4 + 3];
}
}
else {
for (i = 0, row = firstRow; row <= lastRow; row++) {
value[i++] = m[row + 0];
value[i++] = m[row + 4];
value[i++] = m[row + 8];
value[i++] = m[row + 12];
}
}
}
return;
case STATE_NUM_SAMPLES:
((int *)value)[0] = ctx->DrawBuffer->Visual.samples;
return;
case STATE_DEPTH_RANGE:
value[0] = ctx->ViewportArray[0].Near; /* near */
value[1] = ctx->ViewportArray[0].Far; /* far */
value[2] = ctx->ViewportArray[0].Far - ctx->ViewportArray[0].Near; /* far - near */
value[3] = 1.0;
return;
case STATE_FRAGMENT_PROGRAM:
{
/* state[1] = {STATE_ENV, STATE_LOCAL} */
/* state[2] = parameter index */
const int idx = (int) state[2];
switch (state[1]) {
case STATE_ENV:
COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
return;
case STATE_LOCAL:
if (!ctx->FragmentProgram.Current->Base.LocalParams) {
ctx->FragmentProgram.Current->Base.LocalParams =
calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
if (!ctx->FragmentProgram.Current->Base.LocalParams)
return;
}
COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
return;
default:
_mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
return;
}
}
return;
case STATE_VERTEX_PROGRAM:
{
/* state[1] = {STATE_ENV, STATE_LOCAL} */
/* state[2] = parameter index */
const int idx = (int) state[2];
switch (state[1]) {
case STATE_ENV:
COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
return;
case STATE_LOCAL:
if (!ctx->VertexProgram.Current->Base.LocalParams) {
ctx->VertexProgram.Current->Base.LocalParams =
calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
if (!ctx->VertexProgram.Current->Base.LocalParams)
return;
}
COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
return;
default:
_mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
return;
}
}
return;
case STATE_NORMAL_SCALE:
ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
return;
case STATE_INTERNAL:
switch (state[1]) {
case STATE_CURRENT_ATTRIB:
{
const GLuint idx = (GLuint) state[2];
COPY_4V(value, ctx->Current.Attrib[idx]);
}
return;
case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
{
const GLuint idx = (GLuint) state[2];
if(ctx->Light._ClampVertexColor &&
(idx == VERT_ATTRIB_COLOR0 ||
idx == VERT_ATTRIB_COLOR1)) {
value[0] = CLAMP(ctx->Current.Attrib[idx][0], 0.0f, 1.0f);
value[1] = CLAMP(ctx->Current.Attrib[idx][1], 0.0f, 1.0f);
value[2] = CLAMP(ctx->Current.Attrib[idx][2], 0.0f, 1.0f);
value[3] = CLAMP(ctx->Current.Attrib[idx][3], 0.0f, 1.0f);
}
else
COPY_4V(value, ctx->Current.Attrib[idx]);
}
return;
case STATE_NORMAL_SCALE:
ASSIGN_4V(value,
ctx->_ModelViewInvScale,
ctx->_ModelViewInvScale,
ctx->_ModelViewInvScale,
1);
return;
case STATE_TEXRECT_SCALE:
/* Value = { 1/texWidth, 1/texHeight, 0, 1 }.
* Used to convert unnormalized texcoords to normalized texcoords.
*/
{
const int unit = (int) state[2];
const struct gl_texture_object *texObj
= ctx->Texture.Unit[unit]._Current;
if (texObj) {
struct gl_texture_image *texImage = texObj->Image[0][0];
ASSIGN_4V(value,
(GLfloat) (1.0 / texImage->Width),
(GLfloat) (1.0 / texImage->Height),
0.0f, 1.0f);
}
}
return;
case STATE_FOG_PARAMS_OPTIMIZED:
/* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
* might be more expensive than EX2 on some hw, plus it needs
* another constant (e) anyway. Linear fog can now be done with a
* single MAD.
* linear: fogcoord * -1/(end-start) + end/(end-start)
* exp: 2^-(density/ln(2) * fogcoord)
* exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
*/
value[0] = (ctx->Fog.End == ctx->Fog.Start)
? 1.0f : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
value[1] = ctx->Fog.End * -value[0];
value[2] = (GLfloat)(ctx->Fog.Density * M_LOG2E); /* M_LOG2E == 1/ln(2) */
value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
return;
case STATE_POINT_SIZE_CLAMPED:
{
/* this includes implementation dependent limits, to avoid
* another potentially necessary clamp.
* Note: for sprites, point smooth (point AA) is ignored
* and we'll clamp to MinPointSizeAA and MaxPointSize, because we
* expect drivers will want to say their minimum for AA size is 0.0
* but for non-AA it's 1.0 (because normal points with size below 1.0
* need to get rounded up to 1.0, hence never disappear). GL does
* not specify max clamp size for sprites, other than it needs to be
* at least as large as max AA size, hence use non-AA size there.
*/
GLfloat minImplSize;
GLfloat maxImplSize;
if (ctx->Point.PointSprite) {
minImplSize = ctx->Const.MinPointSizeAA;
maxImplSize = ctx->Const.MaxPointSize;
}
else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) {
minImplSize = ctx->Const.MinPointSizeAA;
maxImplSize = ctx->Const.MaxPointSizeAA;
}
else {
minImplSize = ctx->Const.MinPointSize;
maxImplSize = ctx->Const.MaxPointSize;
}
value[0] = ctx->Point.Size;
value[1] = ctx->Point.MinSize >= minImplSize ? ctx->Point.MinSize : minImplSize;
value[2] = ctx->Point.MaxSize <= maxImplSize ? ctx->Point.MaxSize : maxImplSize;
value[3] = ctx->Point.Threshold;
}
return;
case STATE_LIGHT_SPOT_DIR_NORMALIZED:
{
/* here, state[2] is the light number */
/* pre-normalize spot dir */
const GLuint ln = (GLuint) state[2];
COPY_3V(value, ctx->Light.Light[ln]._NormSpotDirection);
value[3] = ctx->Light.Light[ln]._CosCutoff;
}
return;
case STATE_LIGHT_POSITION:
{
const GLuint ln = (GLuint) state[2];
COPY_4V(value, ctx->Light.Light[ln]._Position);
}
return;
case STATE_LIGHT_POSITION_NORMALIZED:
{
const GLuint ln = (GLuint) state[2];
COPY_4V(value, ctx->Light.Light[ln]._Position);
NORMALIZE_3FV( value );
}
return;
case STATE_LIGHT_HALF_VECTOR:
{
const GLuint ln = (GLuint) state[2];
GLfloat p[3];
/* Compute infinite half angle vector:
* halfVector = normalize(normalize(lightPos) + (0, 0, 1))
* light.EyePosition.w should be 0 for infinite lights.
*/
COPY_3V(p, ctx->Light.Light[ln]._Position);
NORMALIZE_3FV(p);
ADD_3V(value, p, ctx->_EyeZDir);
NORMALIZE_3FV(value);
value[3] = 1.0;
}
return;
case STATE_PT_SCALE:
value[0] = ctx->Pixel.RedScale;
value[1] = ctx->Pixel.GreenScale;
value[2] = ctx->Pixel.BlueScale;
value[3] = ctx->Pixel.AlphaScale;
return;
case STATE_PT_BIAS:
value[0] = ctx->Pixel.RedBias;
value[1] = ctx->Pixel.GreenBias;
value[2] = ctx->Pixel.BlueBias;
value[3] = ctx->Pixel.AlphaBias;
return;
case STATE_FB_SIZE:
value[0] = (GLfloat) (ctx->DrawBuffer->Width - 1);
value[1] = (GLfloat) (ctx->DrawBuffer->Height - 1);
value[2] = 0.0F;
value[3] = 0.0F;
return;
case STATE_FB_WPOS_Y_TRANSFORM:
/* A driver may negate this conditional by using ZW swizzle
* instead of XY (based on e.g. some other state). */
if (_mesa_is_user_fbo(ctx->DrawBuffer)) {
/* Identity (XY) followed by flipping Y upside down (ZW). */
value[0] = 1.0F;
value[1] = 0.0F;
value[2] = -1.0F;
value[3] = (GLfloat) ctx->DrawBuffer->Height;
} else {
/* Flipping Y upside down (XY) followed by identity (ZW). */
value[0] = -1.0F;
value[1] = (GLfloat) ctx->DrawBuffer->Height;
value[2] = 1.0F;
value[3] = 0.0F;
}
return;
/* XXX: make sure new tokens added here are also handled in the
* _mesa_program_state_flags() switch, below.
*/
default:
/* Unknown state indexes are silently ignored here.
* Drivers may do something special.
*/
return;
}
return;
default:
_mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
return;
}
}
void glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
{
GLuint maxUnit;
const struct gl_texture_unit *texUnit;
GET_CURRENT_CONTEXT(ctx);
maxUnit = ctx->Const.MaxCombinedTextureImageUnits;
// maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
// ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits;
if (ctx->Texture.CurrentUnit >= maxUnit) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnvfv(current unit)");
return;
}
texUnit = _mesa_get_current_tex_unit(ctx);
if (target == GL_TEXTURE_ENV) {
if (pname == GL_TEXTURE_ENV_COLOR) {
if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
_mesa_update_state(ctx);
if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
COPY_4FV( params, texUnit->EnvColor );
else
COPY_4FV( params, texUnit->EnvColorUnclamped );
}
else {
GLint val = get_texenvi(ctx, texUnit, pname);
if (val >= 0) {
*params = (GLfloat) val;
}
}
}
else if (target == GL_TEXTURE_FILTER_CONTROL) {
if (pname == GL_TEXTURE_LOD_BIAS) {
*params = texUnit->LodBias;
}
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
return;
}
}
// else if (target == GL_POINT_SPRITE_NV) {
// /* GL_ARB_point_sprite / GL_NV_point_sprite */
// if (!ctx->Extensions.NV_point_sprite
// && !ctx->Extensions.ARB_point_sprite) {
// _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
// return;
// }
// if (pname == GL_COORD_REPLACE_NV) {
// *params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
// }
// else {
// _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
// return;
// }
// }
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
return;
}
}
