/* 
 * Copyright (C) 2010 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 * 
 * Contact:
 * DongKyun Yun <dk77.yun@samsung.com>
 * SangJin Kim <sangjin3.kim@samsung.com>
 * HyunGoo Kang <hyungoo1.kang@samsung.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is furnished to do
 * so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * Contributors:
 * - S-Core Co., Ltd
 *
 */

#include "gl_imp.h"
#include <GLES/glext.h>


#if ! defined(GL_COORD_REPLACE)
#define	GL_COORD_REPLACE	GL_COORD_REPLACE_OES 
#endif


static const GLint INTFN(mapFormat)[] = {
	0,
	GL_LUMINANCE,
	GL_LUMINANCE_ALPHA,
	GL_RGB,
	GL_RGBA
};

GL_API void GL_APIENTRY EXTFN(TexImage2D)(GLenum target,
        GLint level, GLint internalformat, GLsizei width, GLsizei height,
        GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
	int iMaxSize;
	if (1 <= internalformat && internalformat <= 4) {
		internalformat = INTFN(mapFormat)[internalformat];
	}
	if (1 <= format && format <= 4) {
		format = INTFN(mapFormat)[format];
	}
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
		FNPTR(GetIntegerv)(GL_MAX_TEXTURE_SIZE, &iMaxSize);
		break;
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES:
		if (width != height) {
			INTFN(SetError)(GL_INVALID_VALUE);
			return;
		}
		FNPTR(GetIntegerv)(GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES, &iMaxSize);
		break;
#endif
	}
	if (width < 0 || iMaxSize < width || height < 0 || iMaxSize < height) {
		INTFN(SetError)(GL_INVALID_VALUE);
		return;
	}
	if (format < GL_ALPHA || GL_LUMINANCE_ALPHA < format
	        || (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 &&
	            type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_SHORT_5_6_5)) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	if (internalformat < GL_ALPHA || GL_LUMINANCE_ALPHA < internalformat
	        || border != 0) {
		INTFN(SetError)(GL_INVALID_VALUE);
		return;
	}
	if (internalformat != (GLint)format) {
		INTFN(SetError)(GL_INVALID_OPERATION);
		return;
	}

	FNPTR(TexImage2D)(target, level, internalformat, width, height, border, format, type, pixels);
}

GL_API void GL_APIENTRY EXTFN(TexSubImage2D)(GLenum target,
        GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
        GLenum format, GLenum type, const GLvoid* pixels) {
	int iMaxSize;
	if (1 <= format && format <= 4) {
		format = INTFN(mapFormat)[format];
	}
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
		FNPTR(GetIntegerv)(GL_MAX_TEXTURE_SIZE, &iMaxSize);
		break;
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES:
		if (width != height) {
			INTFN(SetError)(GL_INVALID_VALUE);
			return;
		}
		FNPTR(GetIntegerv)(GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES, &iMaxSize);
		break;
#endif
	}
	if (format < GL_ALPHA || GL_LUMINANCE_ALPHA < format
	        || (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 &&
	            type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_SHORT_5_6_5)) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	FNPTR(TexSubImage2D)(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

GL_API void GL_APIENTRY EXTFN(CopyTexImage2D)(GLenum target,
        GLint level, GLenum internalformat,
        GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
	int iMaxSize;
	if (1 <= internalformat && internalformat <= 4) {
		internalformat = INTFN(mapFormat)[internalformat];
	}
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
		FNPTR(GetIntegerv)(GL_MAX_TEXTURE_SIZE, &iMaxSize);
		break;
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES:
		if (width != height) {
			INTFN(SetError)(GL_INVALID_VALUE);
			return;
		}
		FNPTR(GetIntegerv)(GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES, &iMaxSize);
		break;
#endif
	}
	if (internalformat < GL_ALPHA || GL_LUMINANCE_ALPHA < internalformat) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	if (border != 0) {
		INTFN(SetError)(GL_INVALID_VALUE);
		return;
	}
	FNPTR(CopyTexImage2D)(target, level, internalformat, x, y, width, height, border);
}

GL_API void GL_APIENTRY EXTFN(CopyTexSubImage2D)(GLenum target,
		GLint level, GLint xoffset, GLint yoffset,
		GLint x, GLint y, GLsizei width, GLsizei height) {
	int iMaxSize;
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
		FNPTR(GetIntegerv)(GL_MAX_TEXTURE_SIZE, &iMaxSize);
		break;
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES:
		if (width != height) {
			INTFN(SetError)(GL_INVALID_VALUE);
			return;
		}
		FNPTR(GetIntegerv)(GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES, &iMaxSize);
		break;
#endif
	}
	FNPTR(CopyTexSubImage2D)(target, level, xoffset, yoffset, x, y, width, height);
}

#ifdef ALEXGL_PROVIDE_COMMON
GL_API void GL_APIENTRY EXTFN(TexParameterf)(GLenum target, GLenum pname, GLfloat param) {
	GLint iparam = (int)(param);
	GLfloat error = param - iparam;
	if (error != 0.0F) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	EXTFN(TexParameterx)(target, pname, iparam);
}
#endif

GL_API void GL_APIENTRY EXTFN(TexParameterx)(GLenum target, GLenum pname, GLfixed param) {
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_OES:
#endif
		break;
	}
	switch (pname) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_MIN_FILTER:
		switch (param) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_NEAREST:
		case GL_LINEAR:
		case GL_NEAREST_MIPMAP_NEAREST:
		case GL_LINEAR_MIPMAP_NEAREST:
		case GL_NEAREST_MIPMAP_LINEAR:
		case GL_LINEAR_MIPMAP_LINEAR:
			break;
		}
		break;
	case GL_TEXTURE_MAG_FILTER:
		switch (param) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_NEAREST:
		case GL_LINEAR:
			break;
		}
		break;
	case GL_TEXTURE_WRAP_S:
	case GL_TEXTURE_WRAP_T:
		switch (param) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_CLAMP_TO_EDGE:
		case GL_REPEAT:
#if defined(PROVIDING_OES_texture_mirrored_repeat)
		case GL_MIRRORED_REPEAT_OES:
#endif 
			break;
		}
		break;
	case GL_GENERATE_MIPMAP:
		switch (param) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_TRUE:
		case GL_FALSE:
			break;
		}
		break;
	}
	FNPTR(TexParameteri)(target, pname, param);
}

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexParameteri)(GLenum target, GLenum pname, GLint param) {
	EXTFN(TexParameterx)(target, pname, param);
}
#endif

#ifdef ALEXGL_PROVIDE_COMMON
#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexParameterfv)(GLenum target, GLenum pname, const GLfloat* params) {
	GLint iparam = (int)(*params);
	GLfloat error = *params - iparam;
	if (error != 0.0F) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	EXTFN(TexParameterx)(target, pname, iparam);
}
#endif
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexParameterxv)(GLenum target, GLenum pname, const GLfixed* params) {
	EXTFN(TexParameterx)(target, pname, *params);
}
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexParameteriv)(GLenum target, GLenum pname, const GLint* params) {
	EXTFN(TexParameterx)(target, pname, *params);
}
#endif

#ifdef ALEXGL_PROVIDE_COMMON
#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params) {
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_OES:
#endif
		break;
	}
	switch (pname) {
	case GL_TEXTURE_MIN_FILTER:
	case GL_TEXTURE_MAG_FILTER:
	case GL_TEXTURE_WRAP_S:
	case GL_TEXTURE_WRAP_T:
#if ALEXGL_INTERNAL_VERSION >= 110
	case GL_GENERATE_MIPMAP:
#endif
		FNPTR(GetTexParameterfv)(target, pname, params);
		break;
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
}
#endif
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexParameterxv)(GLenum target, GLenum pname, GLfixed* params) {
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_OES:
#endif
		break;
	}
	switch (pname) {
	case GL_TEXTURE_MIN_FILTER:
	case GL_TEXTURE_MAG_FILTER:
	case GL_TEXTURE_WRAP_S:
	case GL_TEXTURE_WRAP_T:
#if ALEXGL_INTERNAL_VERSION >= 110
	case GL_GENERATE_MIPMAP:
#endif
		FNPTR(GetTexParameteriv)(target, pname, params);
		break;
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
}
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexParameteriv)(GLenum target, GLenum pname, GLint* params) {
	EXTFN(GetTexParameterxv)(target, pname, params);
}
#endif

GL_API void GL_APIENTRY EXTFN(GenTextures)(GLsizei n, GLuint* textures) {
	FNPTR(GenTextures)(n, textures);
}

GL_API void GL_APIENTRY EXTFN(BindTexture)(GLenum target, GLuint texture) {
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_2D:
#if defined(PROVIDING_OES_texture_cube_map)
	case GL_TEXTURE_CUBE_MAP_OES:
#endif
		break;
	}
	FNPTR(BindTexture)(target, texture);
}

GL_API void GL_APIENTRY EXTFN(DeleteTextures)(GLsizei n, const GLuint* textures) {
	FNPTR(DeleteTextures)(n, textures);
}

#ifdef ALEXGL_PROVIDE_1_1
GL_API GLboolean GL_APIENTRY EXTFN(IsTexture)(GLuint texture) {
	return FNPTR(IsTexture)(texture);
}
#endif

#ifdef ALEXGL_PROVIDE_COMMON
GL_API void GL_APIENTRY EXTFN(TexEnvf)(GLenum target, GLenum pname, GLfloat param) {
	if (target == GL_TEXTURE_ENV
			&& (pname == GL_RGB_SCALE || pname == GL_ALPHA_SCALE)) {
		FNPTR(TexEnvf)(target, pname, param);
		return;
	}
	GLint iparam = (int)(param);
	GLfloat error = param - iparam;
	if (error != 0.0F) {
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	}
	EXTFN(TexEnvi)(target, pname, iparam); 
}
#endif

GL_API void GL_APIENTRY EXTFN(TexEnvx)(GLenum target, GLenum pname, GLfixed param) {
	if (target == GL_TEXTURE_ENV
			&& (pname == GL_RGB_SCALE || pname == GL_ALPHA_SCALE)) {
		FNPTR(TexEnvf)(target, pname, x2f(param));
		return;
	}
	EXTFN(TexEnvi)(target, pname, param); 
}

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexEnvi)(GLenum target, GLenum pname, GLint param) {
	switch (target) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV:
		break;
#if defined(PROVIDING_OES_point_sprite)
	case GL_POINT_SPRITE_OES:
		switch (pname) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_COORD_REPLACE_OES:
			FNPTR(TexEnvi)(target, GL_COORD_REPLACE, param);
			return;
		}
		break;
#endif
	}
	switch (pname) {
	case GL_TEXTURE_ENV_MODE:
#if ALEXGL_INTERNAL_VERSION >= 110
		if (param == GL_REPLACE || param == GL_MODULATE || param == GL_DECAL
				|| param == GL_BLEND || param == GL_ADD || param == GL_COMBINE) {
#else
		if (param == GL_REPLACE || param == GL_MODULATE || param == GL_DECAL || param == GL_BLEND) {
#endif
			FNPTR(TexEnvi)(target, pname, param);
			return;
		}
		break;
#if ALEXGL_INTERNAL_VERSION >= 110
	case GL_COMBINE_RGB:
	case GL_COMBINE_ALPHA:
	case GL_OPERAND0_RGB:
	case GL_OPERAND1_RGB:
	case GL_OPERAND2_RGB:
	case GL_OPERAND0_ALPHA:
	case GL_OPERAND1_ALPHA:
	case GL_OPERAND2_ALPHA:
	case GL_RGB_SCALE:
	case GL_ALPHA_SCALE:
		FNPTR(TexEnvi)(target, pname, param);
		return;
	case GL_SRC0_RGB:
	case GL_SRC1_RGB:
	case GL_SRC2_RGB:
	case GL_SRC0_ALPHA:
	case GL_SRC1_ALPHA:
	case GL_SRC2_ALPHA:
		if (param == GL_TEXTURE || param == GL_CONSTANT || param == GL_PRIMARY_COLOR
				|| param == GL_PREVIOUS) {
			FNPTR(TexEnvi)(target, pname, param);
			return;
		}
#if defined(PROVIDING_OES_texture_env_crossbar)
		if (GL_TEXTURE0 <= param && param < GL_TEXTURE0 + ALEXGL_MAX_TEXTURE_UNITS) {
			FNPTR(TexEnvi)(target, pname, param);
			return;
		}
#endif
		break;
#endif
	}
	INTFN(SetError)(GL_INVALID_ENUM);
}
#endif

#ifdef ALEXGL_PROVIDE_COMMON
GL_API void GL_APIENTRY EXTFN(TexEnvfv)(GLenum target, GLenum pname, const GLfloat* params) {
	if (target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_COLOR) {
		FNPTR(TexEnvfv)(target, pname, params);
		return;
	}
	EXTFN(TexEnvf)(target, pname, *params);
}
#endif

GL_API void GL_APIENTRY EXTFN(TexEnvxv)(GLenum target, GLenum pname, const GLfixed* params) {
	if (target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_COLOR) {
		GLfloat f[4];
		xv2fv(params, f, 4);
		FNPTR(TexEnvfv)(target, pname, f);
		return;
	}
	EXTFN(TexEnvx)(target, pname, *params);
}

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(TexEnviv)(GLenum target, GLenum pname, const GLint* params) {
	if (target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_COLOR) {
		GLfloat f[4];
		f[0] = (GLfloat)(params[0]);
		f[1] = (GLfloat)(params[1]);
		f[2] = (GLfloat)(params[2]);
		f[3] = (GLfloat)(params[3]);
		FNPTR(TexEnvfv)(target, pname, f);
		return;
	}
	EXTFN(TexEnvi)(target, pname, *params);
}
#endif

#ifdef ALEXGL_PROVIDE_COMMON
#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexEnvfv)(GLenum env, GLenum pname, GLfloat* params) {
	switch (env) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV:
		break;
#if defined(PROVIDING_OES_point_sprite)
	case GL_POINT_SPRITE_OES:
		switch (pname) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_COORD_REPLACE_OES:
			FNPTR(GetTexEnvfv)(env, GL_COORD_REPLACE, params);
			return;
		}
		break;
#endif
	}
	switch (pname) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV_MODE:
	case GL_TEXTURE_ENV_COLOR:
	case GL_COMBINE_RGB:
	case GL_COMBINE_ALPHA:
	case GL_SRC0_RGB:
	case GL_SRC1_RGB:
	case GL_SRC2_RGB:
	case GL_SRC0_ALPHA:
	case GL_SRC1_ALPHA:
	case GL_SRC2_ALPHA:
	case GL_OPERAND0_RGB:
	case GL_OPERAND1_RGB:
	case GL_OPERAND2_RGB:
	case GL_OPERAND0_ALPHA:
	case GL_OPERAND1_ALPHA:
	case GL_OPERAND2_ALPHA:
	case GL_RGB_SCALE:
	case GL_ALPHA_SCALE:
		FNPTR(GetTexEnvfv)(env, pname, params);
		break;
	}
}
#endif
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexEnvxv)(GLenum env, GLenum pname, GLfixed* params) {
	switch (env) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV:
		break;
#if defined(PROVIDING_OES_point_sprite)
	case GL_POINT_SPRITE_OES:
		switch (pname) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_COORD_REPLACE_OES:
			FNPTR(GetTexEnviv)(env, GL_COORD_REPLACE, params);
			return;
		}
		break;
#endif
	}
	GLfloat f[4];
	switch (pname) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV_COLOR:
		FNPTR(GetTexEnvfv)(env, pname, f);
		fv2xv(f, params, 4);
		break;
	case GL_RGB_SCALE:
	case GL_ALPHA_SCALE:
		FNPTR(GetTexEnvfv)(env, pname, f);
		fv2xv(f, params, 1);
		break;
	case GL_TEXTURE_ENV_MODE:
	case GL_COMBINE_RGB:
	case GL_COMBINE_ALPHA:
	case GL_SRC0_RGB:
	case GL_SRC1_RGB:
	case GL_SRC2_RGB:
	case GL_SRC0_ALPHA:
	case GL_SRC1_ALPHA:
	case GL_SRC2_ALPHA:
	case GL_OPERAND0_RGB:
	case GL_OPERAND1_RGB:
	case GL_OPERAND2_RGB:
	case GL_OPERAND0_ALPHA:
	case GL_OPERAND1_ALPHA:
	case GL_OPERAND2_ALPHA:
		FNPTR(GetTexEnviv)(env, pname, params);
		break;
	}
}
#endif

#ifdef ALEXGL_PROVIDE_1_1
GL_API void GL_APIENTRY EXTFN(GetTexEnviv)(GLenum env, GLenum pname, GLint* params) {
	switch (env) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV:
		break;
#if defined(PROVIDING_OES_point_sprite)
	case GL_POINT_SPRITE_OES:
		switch (pname) {
		default:
			INTFN(SetError)(GL_INVALID_ENUM);
			return;
		case GL_COORD_REPLACE_OES:
			FNPTR(GetTexEnviv)(env, GL_COORD_REPLACE, params);
			return;
		}
		break;
#endif
	}
	switch (pname) {
	default:
		INTFN(SetError)(GL_INVALID_ENUM);
		return;
	case GL_TEXTURE_ENV_MODE:
	case GL_TEXTURE_ENV_COLOR:
	case GL_COMBINE_RGB:
	case GL_COMBINE_ALPHA:
	case GL_SRC0_RGB:
	case GL_SRC1_RGB:
	case GL_SRC2_RGB:
	case GL_SRC0_ALPHA:
	case GL_SRC1_ALPHA:
	case GL_SRC2_ALPHA:
	case GL_OPERAND0_RGB:
	case GL_OPERAND1_RGB:
	case GL_OPERAND2_RGB:
	case GL_OPERAND0_ALPHA:
	case GL_OPERAND1_ALPHA:
	case GL_OPERAND2_ALPHA:
	case GL_RGB_SCALE:
	case GL_ALPHA_SCALE:
		FNPTR(GetTexEnviv)(env, pname, params);
		break;
	}
}
#endif