// flatlib3 GL_HeaderParser.py
// GLErrorLayer_ES2.h

// __gl2_h_
inline void ActiveTexture( GLenum texture )
{
	glActiveTexture( texture );
	FL_GL_ERROR_TRAP( "glActiveTexture" );
}
inline void AttachShader( GLuint program, GLuint shader )
{
	glAttachShader( program, shader );
	FL_GL_ERROR_TRAP( "glAttachShader" );
}
inline void BindAttribLocation( GLuint program, GLuint index, const GLchar * name )
{
	glBindAttribLocation( program, index, name );
	FL_GL_ERROR_TRAP( "glBindAttribLocation" );
}
inline void BindBuffer( GLenum target, GLuint buffer )
{
	glBindBuffer( target, buffer );
	FL_GL_ERROR_TRAP( "glBindBuffer" );
}
inline void BindFramebuffer( GLenum target, GLuint framebuffer )
{
	glBindFramebuffer( target, framebuffer );
	FL_GL_ERROR_TRAP( "glBindFramebuffer" );
}
inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
{
	glBindRenderbuffer( target, renderbuffer );
	FL_GL_ERROR_TRAP( "glBindRenderbuffer" );
}
inline void BindTexture( GLenum target, GLuint texture )
{
	glBindTexture( target, texture );
	FL_GL_ERROR_TRAP( "glBindTexture" );
}
inline void BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
	glBlendColor( red, green, blue, alpha );
	FL_GL_ERROR_TRAP( "glBlendColor" );
}
inline void BlendEquation( GLenum mode )
{
	glBlendEquation( mode );
	FL_GL_ERROR_TRAP( "glBlendEquation" );
}
inline void BlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
{
	glBlendEquationSeparate( modeRGB, modeAlpha );
	FL_GL_ERROR_TRAP( "glBlendEquationSeparate" );
}
inline void BlendFunc( GLenum sfactor, GLenum dfactor )
{
	glBlendFunc( sfactor, dfactor );
	FL_GL_ERROR_TRAP( "glBlendFunc" );
}
inline void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
	glBlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha );
	FL_GL_ERROR_TRAP( "glBlendFuncSeparate" );
}
inline void BufferData( GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage )
{
	glBufferData( target, size, data, usage );
	FL_GL_ERROR_TRAP( "glBufferData" );
}
inline void BufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data )
{
	glBufferSubData( target, offset, size, data );
	FL_GL_ERROR_TRAP( "glBufferSubData" );
}
inline GLenum CheckFramebufferStatus( GLenum target )
{
	GLenum ret= glCheckFramebufferStatus( target );
	FL_GL_ERROR_TRAP( "glCheckFramebufferStatus" );
	return	ret;
}
inline void Clear( GLbitfield mask )
{
	glClear( mask );
	FL_GL_ERROR_TRAP( "glClear" );
}
inline void ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
	glClearColor( red, green, blue, alpha );
	FL_GL_ERROR_TRAP( "glClearColor" );
}
inline void ClearDepthf( GLclampf depth )
{
	glClearDepthf( depth );
	FL_GL_ERROR_TRAP( "glClearDepthf" );
}
inline void ClearStencil( GLint s )
{
	glClearStencil( s );
	FL_GL_ERROR_TRAP( "glClearStencil" );
}
inline void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
{
	glColorMask( red, green, blue, alpha );
	FL_GL_ERROR_TRAP( "glColorMask" );
}
inline void CompileShader( GLuint shader )
{
	glCompileShader( shader );
	FL_GL_ERROR_TRAP( "glCompileShader" );
}
inline void CompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexImage2D" );
}
inline void CompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexSubImage2D" );
}
inline void CopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
	glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
	FL_GL_ERROR_TRAP( "glCopyTexImage2D" );
}
inline void CopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
	glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
	FL_GL_ERROR_TRAP( "glCopyTexSubImage2D" );
}
inline GLuint CreateProgram( )
{
	GLuint ret= glCreateProgram( );
	FL_GL_ERROR_TRAP( "glCreateProgram" );
	return	ret;
}
inline GLuint CreateShader( GLenum type )
{
	GLuint ret= glCreateShader( type );
	FL_GL_ERROR_TRAP( "glCreateShader" );
	return	ret;
}
inline void CullFace( GLenum mode )
{
	glCullFace( mode );
	FL_GL_ERROR_TRAP( "glCullFace" );
}
inline void DeleteBuffers( GLsizei n, const GLuint * buffers )
{
	glDeleteBuffers( n, buffers );
	FL_GL_ERROR_TRAP( "glDeleteBuffers" );
}
inline void DeleteFramebuffers( GLsizei n, const GLuint * framebuffers )
{
	glDeleteFramebuffers( n, framebuffers );
	FL_GL_ERROR_TRAP( "glDeleteFramebuffers" );
}
inline void DeleteProgram( GLuint program )
{
	glDeleteProgram( program );
	FL_GL_ERROR_TRAP( "glDeleteProgram" );
}
inline void DeleteRenderbuffers( GLsizei n, const GLuint * renderbuffers )
{
	glDeleteRenderbuffers( n, renderbuffers );
	FL_GL_ERROR_TRAP( "glDeleteRenderbuffers" );
}
inline void DeleteShader( GLuint shader )
{
	glDeleteShader( shader );
	FL_GL_ERROR_TRAP( "glDeleteShader" );
}
inline void DeleteTextures( GLsizei n, const GLuint * textures )
{
	glDeleteTextures( n, textures );
	FL_GL_ERROR_TRAP( "glDeleteTextures" );
}
inline void DepthFunc( GLenum func )
{
	glDepthFunc( func );
	FL_GL_ERROR_TRAP( "glDepthFunc" );
}
inline void DepthMask( GLboolean flag )
{
	glDepthMask( flag );
	FL_GL_ERROR_TRAP( "glDepthMask" );
}
inline void DepthRangef( GLclampf zNear, GLclampf zFar )
{
	glDepthRangef( zNear, zFar );
	FL_GL_ERROR_TRAP( "glDepthRangef" );
}
inline void DetachShader( GLuint program, GLuint shader )
{
	glDetachShader( program, shader );
	FL_GL_ERROR_TRAP( "glDetachShader" );
}
inline void Disable( GLenum cap )
{
	glDisable( cap );
	FL_GL_ERROR_TRAP( "glDisable" );
}
inline void DisableVertexAttribArray( GLuint index )
{
	glDisableVertexAttribArray( index );
	FL_GL_ERROR_TRAP( "glDisableVertexAttribArray" );
}
inline void DrawArrays( GLenum mode, GLint first, GLsizei count )
{
	glDrawArrays( mode, first, count );
	FL_GL_ERROR_TRAP( "glDrawArrays" );
}
inline void DrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid * indices )
{
	glDrawElements( mode, count, type, indices );
	FL_GL_ERROR_TRAP( "glDrawElements" );
}
inline void Enable( GLenum cap )
{
	glEnable( cap );
	FL_GL_ERROR_TRAP( "glEnable" );
}
inline void EnableVertexAttribArray( GLuint index )
{
	glEnableVertexAttribArray( index );
	FL_GL_ERROR_TRAP( "glEnableVertexAttribArray" );
}
inline void Finish( )
{
	glFinish( );
	FL_GL_ERROR_TRAP( "glFinish" );
}
inline void Flush( )
{
	glFlush( );
	FL_GL_ERROR_TRAP( "glFlush" );
}
inline void FramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
	glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
	FL_GL_ERROR_TRAP( "glFramebufferRenderbuffer" );
}
inline void FramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
	glFramebufferTexture2D( target, attachment, textarget, texture, level );
	FL_GL_ERROR_TRAP( "glFramebufferTexture2D" );
}
inline void FrontFace( GLenum mode )
{
	glFrontFace( mode );
	FL_GL_ERROR_TRAP( "glFrontFace" );
}
inline void GenBuffers( GLsizei n, GLuint * buffers )
{
	glGenBuffers( n, buffers );
	FL_GL_ERROR_TRAP( "glGenBuffers" );
}
inline void GenerateMipmap( GLenum target )
{
	glGenerateMipmap( target );
	FL_GL_ERROR_TRAP( "glGenerateMipmap" );
}
inline void GenFramebuffers( GLsizei n, GLuint * framebuffers )
{
	glGenFramebuffers( n, framebuffers );
	FL_GL_ERROR_TRAP( "glGenFramebuffers" );
}
inline void GenRenderbuffers( GLsizei n, GLuint * renderbuffers )
{
	glGenRenderbuffers( n, renderbuffers );
	FL_GL_ERROR_TRAP( "glGenRenderbuffers" );
}
inline void GenTextures( GLsizei n, GLuint * textures )
{
	glGenTextures( n, textures );
	FL_GL_ERROR_TRAP( "glGenTextures" );
}
inline void GetActiveAttrib( GLuint program, GLuint index, GLsizei bufsize, GLsizei * length, GLint * size, GLenum * type, GLchar * name )
{
	glGetActiveAttrib( program, index, bufsize, length, size, type, name );
	FL_GL_ERROR_TRAP( "glGetActiveAttrib" );
}
inline void GetActiveUniform( GLuint program, GLuint index, GLsizei bufsize, GLsizei * length, GLint * size, GLenum * type, GLchar * name )
{
	glGetActiveUniform( program, index, bufsize, length, size, type, name );
	FL_GL_ERROR_TRAP( "glGetActiveUniform" );
}
inline void GetAttachedShaders( GLuint program, GLsizei maxcount, GLsizei * count, GLuint * shaders )
{
	glGetAttachedShaders( program, maxcount, count, shaders );
	FL_GL_ERROR_TRAP( "glGetAttachedShaders" );
}
inline GLint GetAttribLocation( GLuint program, const GLchar * name )
{
	GLint ret= glGetAttribLocation( program, name );
	FL_GL_ERROR_TRAP( "glGetAttribLocation" );
	return	ret;
}
inline void GetBooleanv( GLenum pname, GLboolean * params )
{
	glGetBooleanv( pname, params );
	FL_GL_ERROR_TRAP( "glGetBooleanv" );
}
inline void GetBufferParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetBufferParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetBufferParameteriv" );
}
inline GLenum GetError( )
{
	GLenum ret= glGetError( );
	FL_GL_ERROR_TRAP( "glGetError" );
	return	ret;
}
inline void GetFloatv( GLenum pname, GLfloat * params )
{
	glGetFloatv( pname, params );
	FL_GL_ERROR_TRAP( "glGetFloatv" );
}
inline void GetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint * params )
{
	glGetFramebufferAttachmentParameteriv( target, attachment, pname, params );
	FL_GL_ERROR_TRAP( "glGetFramebufferAttachmentParameteriv" );
}
inline void GetIntegerv( GLenum pname, GLint * params )
{
	glGetIntegerv( pname, params );
	FL_GL_ERROR_TRAP( "glGetIntegerv" );
}
inline void GetProgramiv( GLuint program, GLenum pname, GLint * params )
{
	glGetProgramiv( program, pname, params );
	FL_GL_ERROR_TRAP( "glGetProgramiv" );
}
inline void GetProgramInfoLog( GLuint program, GLsizei bufsize, GLsizei * length, GLchar * infolog )
{
	glGetProgramInfoLog( program, bufsize, length, infolog );
	FL_GL_ERROR_TRAP( "glGetProgramInfoLog" );
}
inline void GetRenderbufferParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetRenderbufferParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetRenderbufferParameteriv" );
}
inline void GetShaderiv( GLuint shader, GLenum pname, GLint * params )
{
	glGetShaderiv( shader, pname, params );
	FL_GL_ERROR_TRAP( "glGetShaderiv" );
}
inline void GetShaderInfoLog( GLuint shader, GLsizei bufsize, GLsizei * length, GLchar * infolog )
{
	glGetShaderInfoLog( shader, bufsize, length, infolog );
	FL_GL_ERROR_TRAP( "glGetShaderInfoLog" );
}
inline void GetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision )
{
	glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision );
	FL_GL_ERROR_TRAP( "glGetShaderPrecisionFormat" );
}
inline void GetShaderSource( GLuint shader, GLsizei bufsize, GLsizei * length, GLchar * source )
{
	glGetShaderSource( shader, bufsize, length, source );
	FL_GL_ERROR_TRAP( "glGetShaderSource" );
}
inline const GLubyte * GetString( GLenum name )
{
	const GLubyte * ret= glGetString( name );
	FL_GL_ERROR_TRAP( "glGetString" );
	return	ret;
}
inline void GetTexParameterfv( GLenum target, GLenum pname, GLfloat * params )
{
	glGetTexParameterfv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexParameterfv" );
}
inline void GetTexParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetTexParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexParameteriv" );
}
inline void GetUniformfv( GLuint program, GLint location, GLfloat * params )
{
	glGetUniformfv( program, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformfv" );
}
inline void GetUniformiv( GLuint program, GLint location, GLint * params )
{
	glGetUniformiv( program, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformiv" );
}
inline GLint GetUniformLocation( GLuint program, const GLchar * name )
{
	GLint ret= glGetUniformLocation( program, name );
	FL_GL_ERROR_TRAP( "glGetUniformLocation" );
	return	ret;
}
inline void GetVertexAttribfv( GLuint index, GLenum pname, GLfloat * params )
{
	glGetVertexAttribfv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribfv" );
}
inline void GetVertexAttribiv( GLuint index, GLenum pname, GLint * params )
{
	glGetVertexAttribiv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribiv" );
}
inline void GetVertexAttribPointerv( GLuint index, GLenum pname, GLvoid * * pointer )
{
	glGetVertexAttribPointerv( index, pname, pointer );
	FL_GL_ERROR_TRAP( "glGetVertexAttribPointerv" );
}
inline void Hint( GLenum target, GLenum mode )
{
	glHint( target, mode );
	FL_GL_ERROR_TRAP( "glHint" );
}
inline GLboolean IsBuffer( GLuint buffer )
{
	GLboolean ret= glIsBuffer( buffer );
	FL_GL_ERROR_TRAP( "glIsBuffer" );
	return	ret;
}
inline GLboolean IsEnabled( GLenum cap )
{
	GLboolean ret= glIsEnabled( cap );
	FL_GL_ERROR_TRAP( "glIsEnabled" );
	return	ret;
}
inline GLboolean IsFramebuffer( GLuint framebuffer )
{
	GLboolean ret= glIsFramebuffer( framebuffer );
	FL_GL_ERROR_TRAP( "glIsFramebuffer" );
	return	ret;
}
inline GLboolean IsProgram( GLuint program )
{
	GLboolean ret= glIsProgram( program );
	FL_GL_ERROR_TRAP( "glIsProgram" );
	return	ret;
}
inline GLboolean IsRenderbuffer( GLuint renderbuffer )
{
	GLboolean ret= glIsRenderbuffer( renderbuffer );
	FL_GL_ERROR_TRAP( "glIsRenderbuffer" );
	return	ret;
}
inline GLboolean IsShader( GLuint shader )
{
	GLboolean ret= glIsShader( shader );
	FL_GL_ERROR_TRAP( "glIsShader" );
	return	ret;
}
inline GLboolean IsTexture( GLuint texture )
{
	GLboolean ret= glIsTexture( texture );
	FL_GL_ERROR_TRAP( "glIsTexture" );
	return	ret;
}
inline void LineWidth( GLfloat width )
{
	glLineWidth( width );
	FL_GL_ERROR_TRAP( "glLineWidth" );
}
inline void LinkProgram( GLuint program )
{
	glLinkProgram( program );
	FL_GL_ERROR_TRAP( "glLinkProgram" );
}
inline void PixelStorei( GLenum pname, GLint param )
{
	glPixelStorei( pname, param );
	FL_GL_ERROR_TRAP( "glPixelStorei" );
}
inline void PolygonOffset( GLfloat factor, GLfloat units )
{
	glPolygonOffset( factor, units );
	FL_GL_ERROR_TRAP( "glPolygonOffset" );
}
inline void ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels )
{
	glReadPixels( x, y, width, height, format, type, pixels );
	FL_GL_ERROR_TRAP( "glReadPixels" );
}
inline void ReleaseShaderCompiler( )
{
	glReleaseShaderCompiler( );
	FL_GL_ERROR_TRAP( "glReleaseShaderCompiler" );
}
inline void RenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
{
	glRenderbufferStorage( target, internalformat, width, height );
	FL_GL_ERROR_TRAP( "glRenderbufferStorage" );
}
inline void SampleCoverage( GLclampf value, GLboolean invert )
{
	glSampleCoverage( value, invert );
	FL_GL_ERROR_TRAP( "glSampleCoverage" );
}
inline void Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
{
	glScissor( x, y, width, height );
	FL_GL_ERROR_TRAP( "glScissor" );
}
inline void ShaderBinary( GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length )
{
	glShaderBinary( n, shaders, binaryformat, binary, length );
	FL_GL_ERROR_TRAP( "glShaderBinary" );
}
inline void ShaderSource( GLuint shader, GLsizei count, const GLchar * const * string, const GLint * length )
{
	glShaderSource( shader, count, string, length );
	FL_GL_ERROR_TRAP( "glShaderSource" );
}
inline void StencilFunc( GLenum func, GLint ref, GLuint mask )
{
	glStencilFunc( func, ref, mask );
	FL_GL_ERROR_TRAP( "glStencilFunc" );
}
inline void StencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
{
	glStencilFuncSeparate( face, func, ref, mask );
	FL_GL_ERROR_TRAP( "glStencilFuncSeparate" );
}
inline void StencilMask( GLuint mask )
{
	glStencilMask( mask );
	FL_GL_ERROR_TRAP( "glStencilMask" );
}
inline void StencilMaskSeparate( GLenum face, GLuint mask )
{
	glStencilMaskSeparate( face, mask );
	FL_GL_ERROR_TRAP( "glStencilMaskSeparate" );
}
inline void StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
{
	glStencilOp( fail, zfail, zpass );
	FL_GL_ERROR_TRAP( "glStencilOp" );
}
inline void StencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass )
{
	glStencilOpSeparate( face, fail, zfail, zpass );
	FL_GL_ERROR_TRAP( "glStencilOpSeparate" );
}
inline void TexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexImage2D" );
}
inline void TexParameterf( GLenum target, GLenum pname, GLfloat param )
{
	glTexParameterf( target, pname, param );
	FL_GL_ERROR_TRAP( "glTexParameterf" );
}
inline void TexParameterfv( GLenum target, GLenum pname, const GLfloat * params )
{
	glTexParameterfv( target, pname, params );
	FL_GL_ERROR_TRAP( "glTexParameterfv" );
}
inline void TexParameteri( GLenum target, GLenum pname, GLint param )
{
	glTexParameteri( target, pname, param );
	FL_GL_ERROR_TRAP( "glTexParameteri" );
}
inline void TexParameteriv( GLenum target, GLenum pname, const GLint * params )
{
	glTexParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glTexParameteriv" );
}
inline void TexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexSubImage2D" );
}
inline void Uniform1f( GLint location, GLfloat x )
{
	glUniform1f( location, x );
	FL_GL_ERROR_TRAP( "glUniform1f" );
}
inline void Uniform1fv( GLint location, GLsizei count, const GLfloat * v )
{
	glUniform1fv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform1fv" );
}
inline void Uniform1i( GLint location, GLint x )
{
	glUniform1i( location, x );
	FL_GL_ERROR_TRAP( "glUniform1i" );
}
inline void Uniform1iv( GLint location, GLsizei count, const GLint * v )
{
	glUniform1iv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform1iv" );
}
inline void Uniform2f( GLint location, GLfloat x, GLfloat y )
{
	glUniform2f( location, x, y );
	FL_GL_ERROR_TRAP( "glUniform2f" );
}
inline void Uniform2fv( GLint location, GLsizei count, const GLfloat * v )
{
	glUniform2fv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform2fv" );
}
inline void Uniform2i( GLint location, GLint x, GLint y )
{
	glUniform2i( location, x, y );
	FL_GL_ERROR_TRAP( "glUniform2i" );
}
inline void Uniform2iv( GLint location, GLsizei count, const GLint * v )
{
	glUniform2iv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform2iv" );
}
inline void Uniform3f( GLint location, GLfloat x, GLfloat y, GLfloat z )
{
	glUniform3f( location, x, y, z );
	FL_GL_ERROR_TRAP( "glUniform3f" );
}
inline void Uniform3fv( GLint location, GLsizei count, const GLfloat * v )
{
	glUniform3fv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform3fv" );
}
inline void Uniform3i( GLint location, GLint x, GLint y, GLint z )
{
	glUniform3i( location, x, y, z );
	FL_GL_ERROR_TRAP( "glUniform3i" );
}
inline void Uniform3iv( GLint location, GLsizei count, const GLint * v )
{
	glUniform3iv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform3iv" );
}
inline void Uniform4f( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
	glUniform4f( location, x, y, z, w );
	FL_GL_ERROR_TRAP( "glUniform4f" );
}
inline void Uniform4fv( GLint location, GLsizei count, const GLfloat * v )
{
	glUniform4fv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform4fv" );
}
inline void Uniform4i( GLint location, GLint x, GLint y, GLint z, GLint w )
{
	glUniform4i( location, x, y, z, w );
	FL_GL_ERROR_TRAP( "glUniform4i" );
}
inline void Uniform4iv( GLint location, GLsizei count, const GLint * v )
{
	glUniform4iv( location, count, v );
	FL_GL_ERROR_TRAP( "glUniform4iv" );
}
inline void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix2fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2fv" );
}
inline void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix3fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3fv" );
}
inline void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix4fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4fv" );
}
inline void UseProgram( GLuint program )
{
	glUseProgram( program );
	FL_GL_ERROR_TRAP( "glUseProgram" );
}
inline void ValidateProgram( GLuint program )
{
	glValidateProgram( program );
	FL_GL_ERROR_TRAP( "glValidateProgram" );
}
inline void VertexAttrib1f( GLuint indx, GLfloat x )
{
	glVertexAttrib1f( indx, x );
	FL_GL_ERROR_TRAP( "glVertexAttrib1f" );
}
inline void VertexAttrib1fv( GLuint indx, const GLfloat * values )
{
	glVertexAttrib1fv( indx, values );
	FL_GL_ERROR_TRAP( "glVertexAttrib1fv" );
}
inline void VertexAttrib2f( GLuint indx, GLfloat x, GLfloat y )
{
	glVertexAttrib2f( indx, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttrib2f" );
}
inline void VertexAttrib2fv( GLuint indx, const GLfloat * values )
{
	glVertexAttrib2fv( indx, values );
	FL_GL_ERROR_TRAP( "glVertexAttrib2fv" );
}
inline void VertexAttrib3f( GLuint indx, GLfloat x, GLfloat y, GLfloat z )
{
	glVertexAttrib3f( indx, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttrib3f" );
}
inline void VertexAttrib3fv( GLuint indx, const GLfloat * values )
{
	glVertexAttrib3fv( indx, values );
	FL_GL_ERROR_TRAP( "glVertexAttrib3fv" );
}
inline void VertexAttrib4f( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
	glVertexAttrib4f( indx, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttrib4f" );
}
inline void VertexAttrib4fv( GLuint indx, const GLfloat * values )
{
	glVertexAttrib4fv( indx, values );
	FL_GL_ERROR_TRAP( "glVertexAttrib4fv" );
}
inline void VertexAttribPointer( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * ptr )
{
	glVertexAttribPointer( indx, size, type, normalized, stride, ptr );
	FL_GL_ERROR_TRAP( "glVertexAttribPointer" );
}
inline void Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
{
	glViewport( x, y, width, height );
	FL_GL_ERROR_TRAP( "glViewport" );
}
// total=142