// flatlib3 GL_HeaderParser.py
// GLErrorLayer_ES3.h

// __gl3_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( GLfloat red, GLfloat green, GLfloat blue, GLfloat 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( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
	glClearColor( red, green, blue, alpha );
	FL_GL_ERROR_TRAP( "glClearColor" );
}
inline void ClearDepthf( GLfloat 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( GLfloat n, GLfloat f )
{
	glDepthRangef( n, f );
	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( GLfloat 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" );
}
inline void ReadBuffer( GLenum mode )
{
	glReadBuffer( mode );
	FL_GL_ERROR_TRAP( "glReadBuffer" );
}
inline void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices )
{
	glDrawRangeElements( mode, start, end, count, type, indices );
	FL_GL_ERROR_TRAP( "glDrawRangeElements" );
}
inline void TexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexImage3D" );
}
inline void TexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexSubImage3D" );
}
inline void CopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
	glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
	FL_GL_ERROR_TRAP( "glCopyTexSubImage3D" );
}
inline void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexImage3D" );
}
inline void CompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexSubImage3D" );
}
inline void GenQueries( GLsizei n, GLuint * ids )
{
	glGenQueries( n, ids );
	FL_GL_ERROR_TRAP( "glGenQueries" );
}
inline void DeleteQueries( GLsizei n, const GLuint * ids )
{
	glDeleteQueries( n, ids );
	FL_GL_ERROR_TRAP( "glDeleteQueries" );
}
inline GLboolean IsQuery( GLuint id )
{
	GLboolean ret= glIsQuery( id );
	FL_GL_ERROR_TRAP( "glIsQuery" );
	return	ret;
}
inline void BeginQuery( GLenum target, GLuint id )
{
	glBeginQuery( target, id );
	FL_GL_ERROR_TRAP( "glBeginQuery" );
}
inline void EndQuery( GLenum target )
{
	glEndQuery( target );
	FL_GL_ERROR_TRAP( "glEndQuery" );
}
inline void GetQueryiv( GLenum target, GLenum pname, GLint * params )
{
	glGetQueryiv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryiv" );
}
inline void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint * params )
{
	glGetQueryObjectuiv( id, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryObjectuiv" );
}
inline GLboolean UnmapBuffer( GLenum target )
{
	GLboolean ret= glUnmapBuffer( target );
	FL_GL_ERROR_TRAP( "glUnmapBuffer" );
	return	ret;
}
inline void GetBufferPointerv( GLenum target, GLenum pname, GLvoid * * params )
{
	glGetBufferPointerv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetBufferPointerv" );
}
inline void DrawBuffers( GLsizei n, const GLenum * bufs )
{
	glDrawBuffers( n, bufs );
	FL_GL_ERROR_TRAP( "glDrawBuffers" );
}
inline void UniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix2x3fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2x3fv" );
}
inline void UniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix3x2fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3x2fv" );
}
inline void UniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix2x4fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2x4fv" );
}
inline void UniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix4x2fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4x2fv" );
}
inline void UniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix3x4fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3x4fv" );
}
inline void UniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glUniformMatrix4x3fv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4x3fv" );
}
inline void BlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
{
	glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
	FL_GL_ERROR_TRAP( "glBlitFramebuffer" );
}
inline void RenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
{
	glRenderbufferStorageMultisample( target, samples, internalformat, width, height );
	FL_GL_ERROR_TRAP( "glRenderbufferStorageMultisample" );
}
inline void FramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
	glFramebufferTextureLayer( target, attachment, texture, level, layer );
	FL_GL_ERROR_TRAP( "glFramebufferTextureLayer" );
}
inline GLvoid * MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access )
{
	GLvoid * ret= glMapBufferRange( target, offset, length, access );
	FL_GL_ERROR_TRAP( "glMapBufferRange" );
	return	ret;
}
inline void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length )
{
	glFlushMappedBufferRange( target, offset, length );
	FL_GL_ERROR_TRAP( "glFlushMappedBufferRange" );
}
inline void BindVertexArray( GLuint array )
{
	glBindVertexArray( array );
	FL_GL_ERROR_TRAP( "glBindVertexArray" );
}
inline void DeleteVertexArrays( GLsizei n, const GLuint * arrays )
{
	glDeleteVertexArrays( n, arrays );
	FL_GL_ERROR_TRAP( "glDeleteVertexArrays" );
}
inline void GenVertexArrays( GLsizei n, GLuint * arrays )
{
	glGenVertexArrays( n, arrays );
	FL_GL_ERROR_TRAP( "glGenVertexArrays" );
}
inline GLboolean IsVertexArray( GLuint array )
{
	GLboolean ret= glIsVertexArray( array );
	FL_GL_ERROR_TRAP( "glIsVertexArray" );
	return	ret;
}
inline void GetIntegeri_v( GLenum target, GLuint index, GLint * data )
{
	glGetIntegeri_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetIntegeri_v" );
}
inline void BeginTransformFeedback( GLenum primitiveMode )
{
	glBeginTransformFeedback( primitiveMode );
	FL_GL_ERROR_TRAP( "glBeginTransformFeedback" );
}
inline void EndTransformFeedback( )
{
	glEndTransformFeedback( );
	FL_GL_ERROR_TRAP( "glEndTransformFeedback" );
}
inline void BindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
	glBindBufferRange( target, index, buffer, offset, size );
	FL_GL_ERROR_TRAP( "glBindBufferRange" );
}
inline void BindBufferBase( GLenum target, GLuint index, GLuint buffer )
{
	glBindBufferBase( target, index, buffer );
	FL_GL_ERROR_TRAP( "glBindBufferBase" );
}
inline void TransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar * const * varyings, GLenum bufferMode )
{
	glTransformFeedbackVaryings( program, count, varyings, bufferMode );
	FL_GL_ERROR_TRAP( "glTransformFeedbackVaryings" );
}
inline void GetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name )
{
	glGetTransformFeedbackVarying( program, index, bufSize, length, size, type, name );
	FL_GL_ERROR_TRAP( "glGetTransformFeedbackVarying" );
}
inline void VertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer )
{
	glVertexAttribIPointer( index, size, type, stride, pointer );
	FL_GL_ERROR_TRAP( "glVertexAttribIPointer" );
}
inline void GetVertexAttribIiv( GLuint index, GLenum pname, GLint * params )
{
	glGetVertexAttribIiv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribIiv" );
}
inline void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint * params )
{
	glGetVertexAttribIuiv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribIuiv" );
}
inline void VertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w )
{
	glVertexAttribI4i( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttribI4i" );
}
inline void VertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
	glVertexAttribI4ui( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttribI4ui" );
}
inline void VertexAttribI4iv( GLuint index, const GLint * v )
{
	glVertexAttribI4iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4iv" );
}
inline void VertexAttribI4uiv( GLuint index, const GLuint * v )
{
	glVertexAttribI4uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4uiv" );
}
inline void GetUniformuiv( GLuint program, GLint location, GLuint * params )
{
	glGetUniformuiv( program, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformuiv" );
}
inline GLint GetFragDataLocation( GLuint program, const GLchar * name )
{
	GLint ret= glGetFragDataLocation( program, name );
	FL_GL_ERROR_TRAP( "glGetFragDataLocation" );
	return	ret;
}
inline void Uniform1ui( GLint location, GLuint v0 )
{
	glUniform1ui( location, v0 );
	FL_GL_ERROR_TRAP( "glUniform1ui" );
}
inline void Uniform2ui( GLint location, GLuint v0, GLuint v1 )
{
	glUniform2ui( location, v0, v1 );
	FL_GL_ERROR_TRAP( "glUniform2ui" );
}
inline void Uniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
	glUniform3ui( location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glUniform3ui" );
}
inline void Uniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
	glUniform4ui( location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glUniform4ui" );
}
inline void Uniform1uiv( GLint location, GLsizei count, const GLuint * value )
{
	glUniform1uiv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform1uiv" );
}
inline void Uniform2uiv( GLint location, GLsizei count, const GLuint * value )
{
	glUniform2uiv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform2uiv" );
}
inline void Uniform3uiv( GLint location, GLsizei count, const GLuint * value )
{
	glUniform3uiv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform3uiv" );
}
inline void Uniform4uiv( GLint location, GLsizei count, const GLuint * value )
{
	glUniform4uiv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform4uiv" );
}
inline void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint * value )
{
	glClearBufferiv( buffer, drawbuffer, value );
	FL_GL_ERROR_TRAP( "glClearBufferiv" );
}
inline void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint * value )
{
	glClearBufferuiv( buffer, drawbuffer, value );
	FL_GL_ERROR_TRAP( "glClearBufferuiv" );
}
inline void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat * value )
{
	glClearBufferfv( buffer, drawbuffer, value );
	FL_GL_ERROR_TRAP( "glClearBufferfv" );
}
inline void ClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
{
	glClearBufferfi( buffer, drawbuffer, depth, stencil );
	FL_GL_ERROR_TRAP( "glClearBufferfi" );
}
inline const GLubyte * GetStringi( GLenum name, GLuint index )
{
	const GLubyte * ret= glGetStringi( name, index );
	FL_GL_ERROR_TRAP( "glGetStringi" );
	return	ret;
}
inline void CopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
{
	glCopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size );
	FL_GL_ERROR_TRAP( "glCopyBufferSubData" );
}
inline void GetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar * const * uniformNames, GLuint * uniformIndices )
{
	glGetUniformIndices( program, uniformCount, uniformNames, uniformIndices );
	FL_GL_ERROR_TRAP( "glGetUniformIndices" );
}
inline void GetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params )
{
	glGetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params );
	FL_GL_ERROR_TRAP( "glGetActiveUniformsiv" );
}
inline GLuint GetUniformBlockIndex( GLuint program, const GLchar * uniformBlockName )
{
	GLuint ret= glGetUniformBlockIndex( program, uniformBlockName );
	FL_GL_ERROR_TRAP( "glGetUniformBlockIndex" );
	return	ret;
}
inline void GetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params )
{
	glGetActiveUniformBlockiv( program, uniformBlockIndex, pname, params );
	FL_GL_ERROR_TRAP( "glGetActiveUniformBlockiv" );
}
inline void GetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName )
{
	glGetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName );
	FL_GL_ERROR_TRAP( "glGetActiveUniformBlockName" );
}
inline void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding )
{
	glUniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding );
	FL_GL_ERROR_TRAP( "glUniformBlockBinding" );
}
inline void DrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instanceCount )
{
	glDrawArraysInstanced( mode, first, count, instanceCount );
	FL_GL_ERROR_TRAP( "glDrawArraysInstanced" );
}
inline void DrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei instanceCount )
{
	glDrawElementsInstanced( mode, count, type, indices, instanceCount );
	FL_GL_ERROR_TRAP( "glDrawElementsInstanced" );
}
inline GLsync FenceSync( GLenum condition, GLbitfield flags )
{
	GLsync ret= glFenceSync( condition, flags );
	FL_GL_ERROR_TRAP( "glFenceSync" );
	return	ret;
}
inline GLboolean IsSync( GLsync sync )
{
	GLboolean ret= glIsSync( sync );
	FL_GL_ERROR_TRAP( "glIsSync" );
	return	ret;
}
inline void DeleteSync( GLsync sync )
{
	glDeleteSync( sync );
	FL_GL_ERROR_TRAP( "glDeleteSync" );
}
inline GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
{
	GLenum ret= glClientWaitSync( sync, flags, timeout );
	FL_GL_ERROR_TRAP( "glClientWaitSync" );
	return	ret;
}
inline void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
{
	glWaitSync( sync, flags, timeout );
	FL_GL_ERROR_TRAP( "glWaitSync" );
}
inline void GetInteger64v( GLenum pname, GLint64 * params )
{
	glGetInteger64v( pname, params );
	FL_GL_ERROR_TRAP( "glGetInteger64v" );
}
inline void GetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values )
{
	glGetSynciv( sync, pname, bufSize, length, values );
	FL_GL_ERROR_TRAP( "glGetSynciv" );
}
inline void GetInteger64i_v( GLenum target, GLuint index, GLint64 * data )
{
	glGetInteger64i_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetInteger64i_v" );
}
inline void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64 * params )
{
	glGetBufferParameteri64v( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetBufferParameteri64v" );
}
inline void GenSamplers( GLsizei count, GLuint * samplers )
{
	glGenSamplers( count, samplers );
	FL_GL_ERROR_TRAP( "glGenSamplers" );
}
inline void DeleteSamplers( GLsizei count, const GLuint * samplers )
{
	glDeleteSamplers( count, samplers );
	FL_GL_ERROR_TRAP( "glDeleteSamplers" );
}
inline GLboolean IsSampler( GLuint sampler )
{
	GLboolean ret= glIsSampler( sampler );
	FL_GL_ERROR_TRAP( "glIsSampler" );
	return	ret;
}
inline void BindSampler( GLuint unit, GLuint sampler )
{
	glBindSampler( unit, sampler );
	FL_GL_ERROR_TRAP( "glBindSampler" );
}
inline void SamplerParameteri( GLuint sampler, GLenum pname, GLint param )
{
	glSamplerParameteri( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameteri" );
}
inline void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint * param )
{
	glSamplerParameteriv( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameteriv" );
}
inline void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param )
{
	glSamplerParameterf( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameterf" );
}
inline void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat * param )
{
	glSamplerParameterfv( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameterfv" );
}
inline void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint * params )
{
	glGetSamplerParameteriv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameteriv" );
}
inline void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat * params )
{
	glGetSamplerParameterfv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameterfv" );
}
inline void VertexAttribDivisor( GLuint index, GLuint divisor )
{
	glVertexAttribDivisor( index, divisor );
	FL_GL_ERROR_TRAP( "glVertexAttribDivisor" );
}
inline void BindTransformFeedback( GLenum target, GLuint id )
{
	glBindTransformFeedback( target, id );
	FL_GL_ERROR_TRAP( "glBindTransformFeedback" );
}
inline void DeleteTransformFeedbacks( GLsizei n, const GLuint * ids )
{
	glDeleteTransformFeedbacks( n, ids );
	FL_GL_ERROR_TRAP( "glDeleteTransformFeedbacks" );
}
inline void GenTransformFeedbacks( GLsizei n, GLuint * ids )
{
	glGenTransformFeedbacks( n, ids );
	FL_GL_ERROR_TRAP( "glGenTransformFeedbacks" );
}
inline GLboolean IsTransformFeedback( GLuint id )
{
	GLboolean ret= glIsTransformFeedback( id );
	FL_GL_ERROR_TRAP( "glIsTransformFeedback" );
	return	ret;
}
inline void PauseTransformFeedback( )
{
	glPauseTransformFeedback( );
	FL_GL_ERROR_TRAP( "glPauseTransformFeedback" );
}
inline void ResumeTransformFeedback( )
{
	glResumeTransformFeedback( );
	FL_GL_ERROR_TRAP( "glResumeTransformFeedback" );
}
inline void GetProgramBinary( GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary )
{
	glGetProgramBinary( program, bufSize, length, binaryFormat, binary );
	FL_GL_ERROR_TRAP( "glGetProgramBinary" );
}
inline void ProgramBinary( GLuint program, GLenum binaryFormat, const GLvoid * binary, GLsizei length )
{
	glProgramBinary( program, binaryFormat, binary, length );
	FL_GL_ERROR_TRAP( "glProgramBinary" );
}
inline void ProgramParameteri( GLuint program, GLenum pname, GLint value )
{
	glProgramParameteri( program, pname, value );
	FL_GL_ERROR_TRAP( "glProgramParameteri" );
}
inline void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum * attachments )
{
	glInvalidateFramebuffer( target, numAttachments, attachments );
	FL_GL_ERROR_TRAP( "glInvalidateFramebuffer" );
}
inline void InvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height )
{
	glInvalidateSubFramebuffer( target, numAttachments, attachments, x, y, width, height );
	FL_GL_ERROR_TRAP( "glInvalidateSubFramebuffer" );
}
inline void TexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
{
	glTexStorage2D( target, levels, internalformat, width, height );
	FL_GL_ERROR_TRAP( "glTexStorage2D" );
}
inline void TexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
{
	glTexStorage3D( target, levels, internalformat, width, height, depth );
	FL_GL_ERROR_TRAP( "glTexStorage3D" );
}
inline void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params )
{
	glGetInternalformativ( target, internalformat, pname, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetInternalformativ" );
}
// total=246