// flatlib3 GL_HeaderParser.py
// GLErrorLayer_GL4.h

// __glcorearb_h_
// WIN32_LEAN_AND_MEAN
// APIENTRY
// APIENTRYP
// GLAPI
// GL_VERSION_1_0
inline void CullFace( GLenum mode )
{
	glCullFace( mode );
	FL_GL_ERROR_TRAP( "glCullFace" );
}
inline void FrontFace( GLenum mode )
{
	glFrontFace( mode );
	FL_GL_ERROR_TRAP( "glFrontFace" );
}
inline void Hint( GLenum target, GLenum mode )
{
	glHint( target, mode );
	FL_GL_ERROR_TRAP( "glHint" );
}
inline void LineWidth( GLfloat width )
{
	glLineWidth( width );
	FL_GL_ERROR_TRAP( "glLineWidth" );
}
inline void PointSize( GLfloat size )
{
	glPointSize( size );
	FL_GL_ERROR_TRAP( "glPointSize" );
}
inline void PolygonMode( GLenum face, GLenum mode )
{
	glPolygonMode( face, mode );
	FL_GL_ERROR_TRAP( "glPolygonMode" );
}
inline void Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
{
	glScissor( x, y, width, height );
	FL_GL_ERROR_TRAP( "glScissor" );
}
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 TexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexImage1D" );
}
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 DrawBuffer( GLenum mode )
{
	glDrawBuffer( mode );
	FL_GL_ERROR_TRAP( "glDrawBuffer" );
}
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 ClearStencil( GLint s )
{
	glClearStencil( s );
	FL_GL_ERROR_TRAP( "glClearStencil" );
}
inline void ClearDepth( GLdouble depth )
{
	glClearDepth( depth );
	FL_GL_ERROR_TRAP( "glClearDepth" );
}
inline void StencilMask( GLuint mask )
{
	glStencilMask( mask );
	FL_GL_ERROR_TRAP( "glStencilMask" );
}
inline void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
{
	glColorMask( red, green, blue, alpha );
	FL_GL_ERROR_TRAP( "glColorMask" );
}
inline void DepthMask( GLboolean flag )
{
	glDepthMask( flag );
	FL_GL_ERROR_TRAP( "glDepthMask" );
}
inline void Disable( GLenum cap )
{
	glDisable( cap );
	FL_GL_ERROR_TRAP( "glDisable" );
}
inline void Enable( GLenum cap )
{
	glEnable( cap );
	FL_GL_ERROR_TRAP( "glEnable" );
}
inline void Finish( )
{
	glFinish( );
	FL_GL_ERROR_TRAP( "glFinish" );
}
inline void Flush( )
{
	glFlush( );
	FL_GL_ERROR_TRAP( "glFlush" );
}
inline void BlendFunc( GLenum sfactor, GLenum dfactor )
{
	glBlendFunc( sfactor, dfactor );
	FL_GL_ERROR_TRAP( "glBlendFunc" );
}
inline void LogicOp( GLenum opcode )
{
	glLogicOp( opcode );
	FL_GL_ERROR_TRAP( "glLogicOp" );
}
inline void StencilFunc( GLenum func, GLint ref, GLuint mask )
{
	glStencilFunc( func, ref, mask );
	FL_GL_ERROR_TRAP( "glStencilFunc" );
}
inline void StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
{
	glStencilOp( fail, zfail, zpass );
	FL_GL_ERROR_TRAP( "glStencilOp" );
}
inline void DepthFunc( GLenum func )
{
	glDepthFunc( func );
	FL_GL_ERROR_TRAP( "glDepthFunc" );
}
inline void PixelStoref( GLenum pname, GLfloat param )
{
	glPixelStoref( pname, param );
	FL_GL_ERROR_TRAP( "glPixelStoref" );
}
inline void PixelStorei( GLenum pname, GLint param )
{
	glPixelStorei( pname, param );
	FL_GL_ERROR_TRAP( "glPixelStorei" );
}
inline void ReadBuffer( GLenum mode )
{
	glReadBuffer( mode );
	FL_GL_ERROR_TRAP( "glReadBuffer" );
}
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 GetBooleanv( GLenum pname, GLboolean * params )
{
	glGetBooleanv( pname, params );
	FL_GL_ERROR_TRAP( "glGetBooleanv" );
}
inline void GetDoublev( GLenum pname, GLdouble * params )
{
	glGetDoublev( pname, params );
	FL_GL_ERROR_TRAP( "glGetDoublev" );
}
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 GetIntegerv( GLenum pname, GLint * params )
{
	glGetIntegerv( pname, params );
	FL_GL_ERROR_TRAP( "glGetIntegerv" );
}
inline const GLubyte * GetString( GLenum name )
{
	const GLubyte * ret= glGetString( name );
	FL_GL_ERROR_TRAP( "glGetString" );
	return	ret;
}
inline void GetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels )
{
	glGetTexImage( target, level, format, type, pixels );
	FL_GL_ERROR_TRAP( "glGetTexImage" );
}
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 GetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat * params )
{
	glGetTexLevelParameterfv( target, level, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexLevelParameterfv" );
}
inline void GetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint * params )
{
	glGetTexLevelParameteriv( target, level, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexLevelParameteriv" );
}
inline GLboolean IsEnabled( GLenum cap )
{
	GLboolean ret= glIsEnabled( cap );
	FL_GL_ERROR_TRAP( "glIsEnabled" );
	return	ret;
}
inline void DepthRange( GLdouble v_near, GLdouble v_far )
{
	glDepthRange( v_near, v_far );
	FL_GL_ERROR_TRAP( "glDepthRange" );
}
inline void Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
{
	glViewport( x, y, width, height );
	FL_GL_ERROR_TRAP( "glViewport" );
}
// GL_VERSION_1_1
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 GetPointerv( GLenum pname, GLvoid * * params )
{
	glGetPointerv( pname, params );
	FL_GL_ERROR_TRAP( "glGetPointerv" );
}
inline void PolygonOffset( GLfloat factor, GLfloat units )
{
	glPolygonOffset( factor, units );
	FL_GL_ERROR_TRAP( "glPolygonOffset" );
}
inline void CopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
	glCopyTexImage1D( target, level, internalformat, x, y, width, border );
	FL_GL_ERROR_TRAP( "glCopyTexImage1D" );
}
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 CopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
	glCopyTexSubImage1D( target, level, xoffset, x, y, width );
	FL_GL_ERROR_TRAP( "glCopyTexSubImage1D" );
}
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 void TexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels )
{
	glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
	FL_GL_ERROR_TRAP( "glTexSubImage1D" );
}
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 BindTexture( GLenum target, GLuint texture )
{
	glBindTexture( target, texture );
	FL_GL_ERROR_TRAP( "glBindTexture" );
}
inline void DeleteTextures( GLsizei n, const GLuint * textures )
{
	glDeleteTextures( n, textures );
	FL_GL_ERROR_TRAP( "glDeleteTextures" );
}
inline void GenTextures( GLsizei n, GLuint * textures )
{
	glGenTextures( n, textures );
	FL_GL_ERROR_TRAP( "glGenTextures" );
}
inline GLboolean IsTexture( GLuint texture )
{
	GLboolean ret= glIsTexture( texture );
	FL_GL_ERROR_TRAP( "glIsTexture" );
	return	ret;
}
// GL_VERSION_1_2
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 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" );
}
// GL_VERSION_1_3
inline void ActiveTexture( GLenum texture )
{
	glActiveTexture( texture );
	FL_GL_ERROR_TRAP( "glActiveTexture" );
}
inline void SampleCoverage( GLfloat value, GLboolean invert )
{
	glSampleCoverage( value, invert );
	FL_GL_ERROR_TRAP( "glSampleCoverage" );
}
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 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 CompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexImage1D" );
}
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 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 CompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data )
{
	glCompressedTexSubImage1D( target, level, xoffset, width, format, imageSize, data );
	FL_GL_ERROR_TRAP( "glCompressedTexSubImage1D" );
}
inline void GetCompressedTexImage( GLenum target, GLint level, GLvoid * img )
{
	glGetCompressedTexImage( target, level, img );
	FL_GL_ERROR_TRAP( "glGetCompressedTexImage" );
}
// GL_VERSION_1_4
inline void BlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
{
	glBlendFuncSeparate( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
	FL_GL_ERROR_TRAP( "glBlendFuncSeparate" );
}
inline void MultiDrawArrays( GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount )
{
	glMultiDrawArrays( mode, first, count, drawcount );
	FL_GL_ERROR_TRAP( "glMultiDrawArrays" );
}
inline void MultiDrawElements( GLenum mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei drawcount )
{
	glMultiDrawElements( mode, count, type, indices, drawcount );
	FL_GL_ERROR_TRAP( "glMultiDrawElements" );
}
inline void PointParameterf( GLenum pname, GLfloat param )
{
	glPointParameterf( pname, param );
	FL_GL_ERROR_TRAP( "glPointParameterf" );
}
inline void PointParameterfv( GLenum pname, const GLfloat * params )
{
	glPointParameterfv( pname, params );
	FL_GL_ERROR_TRAP( "glPointParameterfv" );
}
inline void PointParameteri( GLenum pname, GLint param )
{
	glPointParameteri( pname, param );
	FL_GL_ERROR_TRAP( "glPointParameteri" );
}
inline void PointParameteriv( GLenum pname, const GLint * params )
{
	glPointParameteriv( pname, params );
	FL_GL_ERROR_TRAP( "glPointParameteriv" );
}
// GL_VERSION_1_5
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 GetQueryObjectiv( GLuint id, GLenum pname, GLint * params )
{
	glGetQueryObjectiv( id, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryObjectiv" );
}
inline void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint * params )
{
	glGetQueryObjectuiv( id, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryObjectuiv" );
}
inline void BindBuffer( GLenum target, GLuint buffer )
{
	glBindBuffer( target, buffer );
	FL_GL_ERROR_TRAP( "glBindBuffer" );
}
inline void DeleteBuffers( GLsizei n, const GLuint * buffers )
{
	glDeleteBuffers( n, buffers );
	FL_GL_ERROR_TRAP( "glDeleteBuffers" );
}
inline void GenBuffers( GLsizei n, GLuint * buffers )
{
	glGenBuffers( n, buffers );
	FL_GL_ERROR_TRAP( "glGenBuffers" );
}
inline GLboolean IsBuffer( GLuint buffer )
{
	GLboolean ret= glIsBuffer( buffer );
	FL_GL_ERROR_TRAP( "glIsBuffer" );
	return	ret;
}
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 void GetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data )
{
	glGetBufferSubData( target, offset, size, data );
	FL_GL_ERROR_TRAP( "glGetBufferSubData" );
}
inline void * MapBuffer( GLenum target, GLenum access )
{
	void * ret= glMapBuffer( target, access );
	FL_GL_ERROR_TRAP( "glMapBuffer" );
	return	ret;
}
inline GLboolean UnmapBuffer( GLenum target )
{
	GLboolean ret= glUnmapBuffer( target );
	FL_GL_ERROR_TRAP( "glUnmapBuffer" );
	return	ret;
}
inline void GetBufferParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetBufferParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetBufferParameteriv" );
}
inline void GetBufferPointerv( GLenum target, GLenum pname, GLvoid * * params )
{
	glGetBufferPointerv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetBufferPointerv" );
}
// GL_VERSION_2_0
inline void BlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
{
	glBlendEquationSeparate( modeRGB, modeAlpha );
	FL_GL_ERROR_TRAP( "glBlendEquationSeparate" );
}
inline void DrawBuffers( GLsizei n, const GLenum * bufs )
{
	glDrawBuffers( n, bufs );
	FL_GL_ERROR_TRAP( "glDrawBuffers" );
}
inline void StencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )
{
	glStencilOpSeparate( face, sfail, dpfail, dppass );
	FL_GL_ERROR_TRAP( "glStencilOpSeparate" );
}
inline void StencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
{
	glStencilFuncSeparate( face, func, ref, mask );
	FL_GL_ERROR_TRAP( "glStencilFuncSeparate" );
}
inline void StencilMaskSeparate( GLenum face, GLuint mask )
{
	glStencilMaskSeparate( face, mask );
	FL_GL_ERROR_TRAP( "glStencilMaskSeparate" );
}
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 CompileShader( GLuint shader )
{
	glCompileShader( shader );
	FL_GL_ERROR_TRAP( "glCompileShader" );
}
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 DeleteProgram( GLuint program )
{
	glDeleteProgram( program );
	FL_GL_ERROR_TRAP( "glDeleteProgram" );
}
inline void DeleteShader( GLuint shader )
{
	glDeleteShader( shader );
	FL_GL_ERROR_TRAP( "glDeleteShader" );
}
inline void DetachShader( GLuint program, GLuint shader )
{
	glDetachShader( program, shader );
	FL_GL_ERROR_TRAP( "glDetachShader" );
}
inline void DisableVertexAttribArray( GLuint index )
{
	glDisableVertexAttribArray( index );
	FL_GL_ERROR_TRAP( "glDisableVertexAttribArray" );
}
inline void EnableVertexAttribArray( GLuint index )
{
	glEnableVertexAttribArray( index );
	FL_GL_ERROR_TRAP( "glEnableVertexAttribArray" );
}
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 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 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 GetShaderSource( GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source )
{
	glGetShaderSource( shader, bufSize, length, source );
	FL_GL_ERROR_TRAP( "glGetShaderSource" );
}
inline GLint GetUniformLocation( GLuint program, const GLchar * name )
{
	GLint ret= glGetUniformLocation( program, name );
	FL_GL_ERROR_TRAP( "glGetUniformLocation" );
	return	ret;
}
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 void GetVertexAttribdv( GLuint index, GLenum pname, GLdouble * params )
{
	glGetVertexAttribdv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribdv" );
}
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 GLboolean IsProgram( GLuint program )
{
	GLboolean ret= glIsProgram( program );
	FL_GL_ERROR_TRAP( "glIsProgram" );
	return	ret;
}
inline GLboolean IsShader( GLuint shader )
{
	GLboolean ret= glIsShader( shader );
	FL_GL_ERROR_TRAP( "glIsShader" );
	return	ret;
}
inline void LinkProgram( GLuint program )
{
	glLinkProgram( program );
	FL_GL_ERROR_TRAP( "glLinkProgram" );
}
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 UseProgram( GLuint program )
{
	glUseProgram( program );
	FL_GL_ERROR_TRAP( "glUseProgram" );
}
inline void Uniform1f( GLint location, GLfloat v0 )
{
	glUniform1f( location, v0 );
	FL_GL_ERROR_TRAP( "glUniform1f" );
}
inline void Uniform2f( GLint location, GLfloat v0, GLfloat v1 )
{
	glUniform2f( location, v0, v1 );
	FL_GL_ERROR_TRAP( "glUniform2f" );
}
inline void Uniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
	glUniform3f( location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glUniform3f" );
}
inline void Uniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
	glUniform4f( location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glUniform4f" );
}
inline void Uniform1i( GLint location, GLint v0 )
{
	glUniform1i( location, v0 );
	FL_GL_ERROR_TRAP( "glUniform1i" );
}
inline void Uniform2i( GLint location, GLint v0, GLint v1 )
{
	glUniform2i( location, v0, v1 );
	FL_GL_ERROR_TRAP( "glUniform2i" );
}
inline void Uniform3i( GLint location, GLint v0, GLint v1, GLint v2 )
{
	glUniform3i( location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glUniform3i" );
}
inline void Uniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
	glUniform4i( location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glUniform4i" );
}
inline void Uniform1fv( GLint location, GLsizei count, const GLfloat * value )
{
	glUniform1fv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform1fv" );
}
inline void Uniform2fv( GLint location, GLsizei count, const GLfloat * value )
{
	glUniform2fv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform2fv" );
}
inline void Uniform3fv( GLint location, GLsizei count, const GLfloat * value )
{
	glUniform3fv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform3fv" );
}
inline void Uniform4fv( GLint location, GLsizei count, const GLfloat * value )
{
	glUniform4fv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform4fv" );
}
inline void Uniform1iv( GLint location, GLsizei count, const GLint * value )
{
	glUniform1iv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform1iv" );
}
inline void Uniform2iv( GLint location, GLsizei count, const GLint * value )
{
	glUniform2iv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform2iv" );
}
inline void Uniform3iv( GLint location, GLsizei count, const GLint * value )
{
	glUniform3iv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform3iv" );
}
inline void Uniform4iv( GLint location, GLsizei count, const GLint * value )
{
	glUniform4iv( location, count, value );
	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 ValidateProgram( GLuint program )
{
	glValidateProgram( program );
	FL_GL_ERROR_TRAP( "glValidateProgram" );
}
inline void VertexAttrib1d( GLuint index, GLdouble x )
{
	glVertexAttrib1d( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttrib1d" );
}
inline void VertexAttrib1dv( GLuint index, const GLdouble * v )
{
	glVertexAttrib1dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib1dv" );
}
inline void VertexAttrib1f( GLuint index, GLfloat x )
{
	glVertexAttrib1f( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttrib1f" );
}
inline void VertexAttrib1fv( GLuint index, const GLfloat * v )
{
	glVertexAttrib1fv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib1fv" );
}
inline void VertexAttrib1s( GLuint index, GLshort x )
{
	glVertexAttrib1s( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttrib1s" );
}
inline void VertexAttrib1sv( GLuint index, const GLshort * v )
{
	glVertexAttrib1sv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib1sv" );
}
inline void VertexAttrib2d( GLuint index, GLdouble x, GLdouble y )
{
	glVertexAttrib2d( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttrib2d" );
}
inline void VertexAttrib2dv( GLuint index, const GLdouble * v )
{
	glVertexAttrib2dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib2dv" );
}
inline void VertexAttrib2f( GLuint index, GLfloat x, GLfloat y )
{
	glVertexAttrib2f( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttrib2f" );
}
inline void VertexAttrib2fv( GLuint index, const GLfloat * v )
{
	glVertexAttrib2fv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib2fv" );
}
inline void VertexAttrib2s( GLuint index, GLshort x, GLshort y )
{
	glVertexAttrib2s( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttrib2s" );
}
inline void VertexAttrib2sv( GLuint index, const GLshort * v )
{
	glVertexAttrib2sv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib2sv" );
}
inline void VertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
	glVertexAttrib3d( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttrib3d" );
}
inline void VertexAttrib3dv( GLuint index, const GLdouble * v )
{
	glVertexAttrib3dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib3dv" );
}
inline void VertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
	glVertexAttrib3f( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttrib3f" );
}
inline void VertexAttrib3fv( GLuint index, const GLfloat * v )
{
	glVertexAttrib3fv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib3fv" );
}
inline void VertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z )
{
	glVertexAttrib3s( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttrib3s" );
}
inline void VertexAttrib3sv( GLuint index, const GLshort * v )
{
	glVertexAttrib3sv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib3sv" );
}
inline void VertexAttrib4Nbv( GLuint index, const GLbyte * v )
{
	glVertexAttrib4Nbv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nbv" );
}
inline void VertexAttrib4Niv( GLuint index, const GLint * v )
{
	glVertexAttrib4Niv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Niv" );
}
inline void VertexAttrib4Nsv( GLuint index, const GLshort * v )
{
	glVertexAttrib4Nsv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nsv" );
}
inline void VertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
{
	glVertexAttrib4Nub( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nub" );
}
inline void VertexAttrib4Nubv( GLuint index, const GLubyte * v )
{
	glVertexAttrib4Nubv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nubv" );
}
inline void VertexAttrib4Nuiv( GLuint index, const GLuint * v )
{
	glVertexAttrib4Nuiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nuiv" );
}
inline void VertexAttrib4Nusv( GLuint index, const GLushort * v )
{
	glVertexAttrib4Nusv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4Nusv" );
}
inline void VertexAttrib4bv( GLuint index, const GLbyte * v )
{
	glVertexAttrib4bv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4bv" );
}
inline void VertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
	glVertexAttrib4d( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttrib4d" );
}
inline void VertexAttrib4dv( GLuint index, const GLdouble * v )
{
	glVertexAttrib4dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4dv" );
}
inline void VertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
	glVertexAttrib4f( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttrib4f" );
}
inline void VertexAttrib4fv( GLuint index, const GLfloat * v )
{
	glVertexAttrib4fv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4fv" );
}
inline void VertexAttrib4iv( GLuint index, const GLint * v )
{
	glVertexAttrib4iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4iv" );
}
inline void VertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
{
	glVertexAttrib4s( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttrib4s" );
}
inline void VertexAttrib4sv( GLuint index, const GLshort * v )
{
	glVertexAttrib4sv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4sv" );
}
inline void VertexAttrib4ubv( GLuint index, const GLubyte * v )
{
	glVertexAttrib4ubv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4ubv" );
}
inline void VertexAttrib4uiv( GLuint index, const GLuint * v )
{
	glVertexAttrib4uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4uiv" );
}
inline void VertexAttrib4usv( GLuint index, const GLushort * v )
{
	glVertexAttrib4usv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttrib4usv" );
}
inline void VertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer )
{
	glVertexAttribPointer( index, size, type, normalized, stride, pointer );
	FL_GL_ERROR_TRAP( "glVertexAttribPointer" );
}
// GL_VERSION_2_1
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" );
}
// GL_VERSION_3_0
inline void ColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
{
	glColorMaski( index, r, g, b, a );
	FL_GL_ERROR_TRAP( "glColorMaski" );
}
inline void GetBooleani_v( GLenum target, GLuint index, GLboolean * data )
{
	glGetBooleani_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetBooleani_v" );
}
inline void GetIntegeri_v( GLenum target, GLuint index, GLint * data )
{
	glGetIntegeri_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetIntegeri_v" );
}
inline void Enablei( GLenum target, GLuint index )
{
	glEnablei( target, index );
	FL_GL_ERROR_TRAP( "glEnablei" );
}
inline void Disablei( GLenum target, GLuint index )
{
	glDisablei( target, index );
	FL_GL_ERROR_TRAP( "glDisablei" );
}
inline GLboolean IsEnabledi( GLenum target, GLuint index )
{
	GLboolean ret= glIsEnabledi( target, index );
	FL_GL_ERROR_TRAP( "glIsEnabledi" );
	return	ret;
}
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 ClampColor( GLenum target, GLenum clamp )
{
	glClampColor( target, clamp );
	FL_GL_ERROR_TRAP( "glClampColor" );
}
inline void BeginConditionalRender( GLuint id, GLenum mode )
{
	glBeginConditionalRender( id, mode );
	FL_GL_ERROR_TRAP( "glBeginConditionalRender" );
}
inline void EndConditionalRender( )
{
	glEndConditionalRender( );
	FL_GL_ERROR_TRAP( "glEndConditionalRender" );
}
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 VertexAttribI1i( GLuint index, GLint x )
{
	glVertexAttribI1i( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttribI1i" );
}
inline void VertexAttribI2i( GLuint index, GLint x, GLint y )
{
	glVertexAttribI2i( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttribI2i" );
}
inline void VertexAttribI3i( GLuint index, GLint x, GLint y, GLint z )
{
	glVertexAttribI3i( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttribI3i" );
}
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 VertexAttribI1ui( GLuint index, GLuint x )
{
	glVertexAttribI1ui( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttribI1ui" );
}
inline void VertexAttribI2ui( GLuint index, GLuint x, GLuint y )
{
	glVertexAttribI2ui( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttribI2ui" );
}
inline void VertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z )
{
	glVertexAttribI3ui( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttribI3ui" );
}
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 VertexAttribI1iv( GLuint index, const GLint * v )
{
	glVertexAttribI1iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI1iv" );
}
inline void VertexAttribI2iv( GLuint index, const GLint * v )
{
	glVertexAttribI2iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI2iv" );
}
inline void VertexAttribI3iv( GLuint index, const GLint * v )
{
	glVertexAttribI3iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI3iv" );
}
inline void VertexAttribI4iv( GLuint index, const GLint * v )
{
	glVertexAttribI4iv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4iv" );
}
inline void VertexAttribI1uiv( GLuint index, const GLuint * v )
{
	glVertexAttribI1uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI1uiv" );
}
inline void VertexAttribI2uiv( GLuint index, const GLuint * v )
{
	glVertexAttribI2uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI2uiv" );
}
inline void VertexAttribI3uiv( GLuint index, const GLuint * v )
{
	glVertexAttribI3uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI3uiv" );
}
inline void VertexAttribI4uiv( GLuint index, const GLuint * v )
{
	glVertexAttribI4uiv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4uiv" );
}
inline void VertexAttribI4bv( GLuint index, const GLbyte * v )
{
	glVertexAttribI4bv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4bv" );
}
inline void VertexAttribI4sv( GLuint index, const GLshort * v )
{
	glVertexAttribI4sv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4sv" );
}
inline void VertexAttribI4ubv( GLuint index, const GLubyte * v )
{
	glVertexAttribI4ubv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4ubv" );
}
inline void VertexAttribI4usv( GLuint index, const GLushort * v )
{
	glVertexAttribI4usv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribI4usv" );
}
inline void GetUniformuiv( GLuint program, GLint location, GLuint * params )
{
	glGetUniformuiv( program, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformuiv" );
}
inline void BindFragDataLocation( GLuint program, GLuint color, const GLchar * name )
{
	glBindFragDataLocation( program, color, name );
	FL_GL_ERROR_TRAP( "glBindFragDataLocation" );
}
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 TexParameterIiv( GLenum target, GLenum pname, const GLint * params )
{
	glTexParameterIiv( target, pname, params );
	FL_GL_ERROR_TRAP( "glTexParameterIiv" );
}
inline void TexParameterIuiv( GLenum target, GLenum pname, const GLuint * params )
{
	glTexParameterIuiv( target, pname, params );
	FL_GL_ERROR_TRAP( "glTexParameterIuiv" );
}
inline void GetTexParameterIiv( GLenum target, GLenum pname, GLint * params )
{
	glGetTexParameterIiv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexParameterIiv" );
}
inline void GetTexParameterIuiv( GLenum target, GLenum pname, GLuint * params )
{
	glGetTexParameterIuiv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetTexParameterIuiv" );
}
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 GLboolean IsRenderbuffer( GLuint renderbuffer )
{
	GLboolean ret= glIsRenderbuffer( renderbuffer );
	FL_GL_ERROR_TRAP( "glIsRenderbuffer" );
	return	ret;
}
inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
{
	glBindRenderbuffer( target, renderbuffer );
	FL_GL_ERROR_TRAP( "glBindRenderbuffer" );
}
inline void DeleteRenderbuffers( GLsizei n, const GLuint * renderbuffers )
{
	glDeleteRenderbuffers( n, renderbuffers );
	FL_GL_ERROR_TRAP( "glDeleteRenderbuffers" );
}
inline void GenRenderbuffers( GLsizei n, GLuint * renderbuffers )
{
	glGenRenderbuffers( n, renderbuffers );
	FL_GL_ERROR_TRAP( "glGenRenderbuffers" );
}
inline void RenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
{
	glRenderbufferStorage( target, internalformat, width, height );
	FL_GL_ERROR_TRAP( "glRenderbufferStorage" );
}
inline void GetRenderbufferParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetRenderbufferParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetRenderbufferParameteriv" );
}
inline GLboolean IsFramebuffer( GLuint framebuffer )
{
	GLboolean ret= glIsFramebuffer( framebuffer );
	FL_GL_ERROR_TRAP( "glIsFramebuffer" );
	return	ret;
}
inline void BindFramebuffer( GLenum target, GLuint framebuffer )
{
	glBindFramebuffer( target, framebuffer );
	FL_GL_ERROR_TRAP( "glBindFramebuffer" );
}
inline void DeleteFramebuffers( GLsizei n, const GLuint * framebuffers )
{
	glDeleteFramebuffers( n, framebuffers );
	FL_GL_ERROR_TRAP( "glDeleteFramebuffers" );
}
inline void GenFramebuffers( GLsizei n, GLuint * framebuffers )
{
	glGenFramebuffers( n, framebuffers );
	FL_GL_ERROR_TRAP( "glGenFramebuffers" );
}
inline GLenum CheckFramebufferStatus( GLenum target )
{
	GLenum ret= glCheckFramebufferStatus( target );
	FL_GL_ERROR_TRAP( "glCheckFramebufferStatus" );
	return	ret;
}
inline void FramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
	glFramebufferTexture1D( target, attachment, textarget, texture, level );
	FL_GL_ERROR_TRAP( "glFramebufferTexture1D" );
}
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 FramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
{
	glFramebufferTexture3D( target, attachment, textarget, texture, level, zoffset );
	FL_GL_ERROR_TRAP( "glFramebufferTexture3D" );
}
inline void FramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
	glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
	FL_GL_ERROR_TRAP( "glFramebufferRenderbuffer" );
}
inline void GetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint * params )
{
	glGetFramebufferAttachmentParameteriv( target, attachment, pname, params );
	FL_GL_ERROR_TRAP( "glGetFramebufferAttachmentParameteriv" );
}
inline void GenerateMipmap( GLenum target )
{
	glGenerateMipmap( target );
	FL_GL_ERROR_TRAP( "glGenerateMipmap" );
}
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 void * MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access )
{
	void * 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;
}
// GL_VERSION_3_1
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 void TexBuffer( GLenum target, GLenum internalformat, GLuint buffer )
{
	glTexBuffer( target, internalformat, buffer );
	FL_GL_ERROR_TRAP( "glTexBuffer" );
}
inline void PrimitiveRestartIndex( GLuint index )
{
	glPrimitiveRestartIndex( index );
	FL_GL_ERROR_TRAP( "glPrimitiveRestartIndex" );
}
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 void GetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName )
{
	glGetActiveUniformName( program, uniformIndex, bufSize, length, uniformName );
	FL_GL_ERROR_TRAP( "glGetActiveUniformName" );
}
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" );
}
// GL_VERSION_3_2
// GLEXT_64_TYPES_DEFINED
inline void DrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex )
{
	glDrawElementsBaseVertex( mode, count, type, indices, basevertex );
	FL_GL_ERROR_TRAP( "glDrawElementsBaseVertex" );
}
inline void DrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex )
{
	glDrawRangeElementsBaseVertex( mode, start, end, count, type, indices, basevertex );
	FL_GL_ERROR_TRAP( "glDrawRangeElementsBaseVertex" );
}
inline void DrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei instancecount, GLint basevertex )
{
	glDrawElementsInstancedBaseVertex( mode, count, type, indices, instancecount, basevertex );
	FL_GL_ERROR_TRAP( "glDrawElementsInstancedBaseVertex" );
}
inline void MultiDrawElementsBaseVertex( GLenum mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei drawcount, const GLint * basevertex )
{
	glMultiDrawElementsBaseVertex( mode, count, type, indices, drawcount, basevertex );
	FL_GL_ERROR_TRAP( "glMultiDrawElementsBaseVertex" );
}
inline void ProvokingVertex( GLenum mode )
{
	glProvokingVertex( mode );
	FL_GL_ERROR_TRAP( "glProvokingVertex" );
}
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 FramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level )
{
	glFramebufferTexture( target, attachment, texture, level );
	FL_GL_ERROR_TRAP( "glFramebufferTexture" );
}
inline void TexImage2DMultisample( GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
	glTexImage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations );
	FL_GL_ERROR_TRAP( "glTexImage2DMultisample" );
}
inline void TexImage3DMultisample( GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
	glTexImage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations );
	FL_GL_ERROR_TRAP( "glTexImage3DMultisample" );
}
inline void GetMultisamplefv( GLenum pname, GLuint index, GLfloat * val )
{
	glGetMultisamplefv( pname, index, val );
	FL_GL_ERROR_TRAP( "glGetMultisamplefv" );
}
inline void SampleMaski( GLuint index, GLbitfield mask )
{
	glSampleMaski( index, mask );
	FL_GL_ERROR_TRAP( "glSampleMaski" );
}
// GL_VERSION_3_3
inline void BindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar * name )
{
	glBindFragDataLocationIndexed( program, colorNumber, index, name );
	FL_GL_ERROR_TRAP( "glBindFragDataLocationIndexed" );
}
inline GLint GetFragDataIndex( GLuint program, const GLchar * name )
{
	GLint ret= glGetFragDataIndex( program, name );
	FL_GL_ERROR_TRAP( "glGetFragDataIndex" );
	return	ret;
}
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 SamplerParameterIiv( GLuint sampler, GLenum pname, const GLint * param )
{
	glSamplerParameterIiv( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameterIiv" );
}
inline void SamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint * param )
{
	glSamplerParameterIuiv( sampler, pname, param );
	FL_GL_ERROR_TRAP( "glSamplerParameterIuiv" );
}
inline void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint * params )
{
	glGetSamplerParameteriv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameteriv" );
}
inline void GetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint * params )
{
	glGetSamplerParameterIiv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameterIiv" );
}
inline void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat * params )
{
	glGetSamplerParameterfv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameterfv" );
}
inline void GetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint * params )
{
	glGetSamplerParameterIuiv( sampler, pname, params );
	FL_GL_ERROR_TRAP( "glGetSamplerParameterIuiv" );
}
inline void QueryCounter( GLuint id, GLenum target )
{
	glQueryCounter( id, target );
	FL_GL_ERROR_TRAP( "glQueryCounter" );
}
inline void GetQueryObjecti64v( GLuint id, GLenum pname, GLint64 * params )
{
	glGetQueryObjecti64v( id, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryObjecti64v" );
}
inline void GetQueryObjectui64v( GLuint id, GLenum pname, GLuint64 * params )
{
	glGetQueryObjectui64v( id, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryObjectui64v" );
}
inline void VertexAttribDivisor( GLuint index, GLuint divisor )
{
	glVertexAttribDivisor( index, divisor );
	FL_GL_ERROR_TRAP( "glVertexAttribDivisor" );
}
inline void VertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
	glVertexAttribP1ui( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP1ui" );
}
inline void VertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint * value )
{
	glVertexAttribP1uiv( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP1uiv" );
}
inline void VertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
	glVertexAttribP2ui( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP2ui" );
}
inline void VertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint * value )
{
	glVertexAttribP2uiv( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP2uiv" );
}
inline void VertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
	glVertexAttribP3ui( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP3ui" );
}
inline void VertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint * value )
{
	glVertexAttribP3uiv( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP3uiv" );
}
inline void VertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
	glVertexAttribP4ui( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP4ui" );
}
inline void VertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint * value )
{
	glVertexAttribP4uiv( index, type, normalized, value );
	FL_GL_ERROR_TRAP( "glVertexAttribP4uiv" );
}
// GL_VERSION_4_0
inline void MinSampleShading( GLfloat value )
{
	glMinSampleShading( value );
	FL_GL_ERROR_TRAP( "glMinSampleShading" );
}
inline void BlendEquationi( GLuint buf, GLenum mode )
{
	glBlendEquationi( buf, mode );
	FL_GL_ERROR_TRAP( "glBlendEquationi" );
}
inline void BlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
{
	glBlendEquationSeparatei( buf, modeRGB, modeAlpha );
	FL_GL_ERROR_TRAP( "glBlendEquationSeparatei" );
}
inline void BlendFunci( GLuint buf, GLenum src, GLenum dst )
{
	glBlendFunci( buf, src, dst );
	FL_GL_ERROR_TRAP( "glBlendFunci" );
}
inline void BlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
	glBlendFuncSeparatei( buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
	FL_GL_ERROR_TRAP( "glBlendFuncSeparatei" );
}
inline void DrawArraysIndirect( GLenum mode, const GLvoid * indirect )
{
	glDrawArraysIndirect( mode, indirect );
	FL_GL_ERROR_TRAP( "glDrawArraysIndirect" );
}
inline void DrawElementsIndirect( GLenum mode, GLenum type, const GLvoid * indirect )
{
	glDrawElementsIndirect( mode, type, indirect );
	FL_GL_ERROR_TRAP( "glDrawElementsIndirect" );
}
inline void Uniform1d( GLint location, GLdouble x )
{
	glUniform1d( location, x );
	FL_GL_ERROR_TRAP( "glUniform1d" );
}
inline void Uniform2d( GLint location, GLdouble x, GLdouble y )
{
	glUniform2d( location, x, y );
	FL_GL_ERROR_TRAP( "glUniform2d" );
}
inline void Uniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z )
{
	glUniform3d( location, x, y, z );
	FL_GL_ERROR_TRAP( "glUniform3d" );
}
inline void Uniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
	glUniform4d( location, x, y, z, w );
	FL_GL_ERROR_TRAP( "glUniform4d" );
}
inline void Uniform1dv( GLint location, GLsizei count, const GLdouble * value )
{
	glUniform1dv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform1dv" );
}
inline void Uniform2dv( GLint location, GLsizei count, const GLdouble * value )
{
	glUniform2dv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform2dv" );
}
inline void Uniform3dv( GLint location, GLsizei count, const GLdouble * value )
{
	glUniform3dv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform3dv" );
}
inline void Uniform4dv( GLint location, GLsizei count, const GLdouble * value )
{
	glUniform4dv( location, count, value );
	FL_GL_ERROR_TRAP( "glUniform4dv" );
}
inline void UniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix2dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2dv" );
}
inline void UniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix3dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3dv" );
}
inline void UniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix4dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4dv" );
}
inline void UniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix2x3dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2x3dv" );
}
inline void UniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix2x4dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix2x4dv" );
}
inline void UniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix3x2dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3x2dv" );
}
inline void UniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix3x4dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix3x4dv" );
}
inline void UniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix4x2dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4x2dv" );
}
inline void UniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glUniformMatrix4x3dv( location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glUniformMatrix4x3dv" );
}
inline void GetUniformdv( GLuint program, GLint location, GLdouble * params )
{
	glGetUniformdv( program, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformdv" );
}
inline GLint GetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar * name )
{
	GLint ret= glGetSubroutineUniformLocation( program, shadertype, name );
	FL_GL_ERROR_TRAP( "glGetSubroutineUniformLocation" );
	return	ret;
}
inline GLuint GetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar * name )
{
	GLuint ret= glGetSubroutineIndex( program, shadertype, name );
	FL_GL_ERROR_TRAP( "glGetSubroutineIndex" );
	return	ret;
}
inline void GetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values )
{
	glGetActiveSubroutineUniformiv( program, shadertype, index, pname, values );
	FL_GL_ERROR_TRAP( "glGetActiveSubroutineUniformiv" );
}
inline void GetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name )
{
	glGetActiveSubroutineUniformName( program, shadertype, index, bufsize, length, name );
	FL_GL_ERROR_TRAP( "glGetActiveSubroutineUniformName" );
}
inline void GetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name )
{
	glGetActiveSubroutineName( program, shadertype, index, bufsize, length, name );
	FL_GL_ERROR_TRAP( "glGetActiveSubroutineName" );
}
inline void UniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint * indices )
{
	glUniformSubroutinesuiv( shadertype, count, indices );
	FL_GL_ERROR_TRAP( "glUniformSubroutinesuiv" );
}
inline void GetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint * params )
{
	glGetUniformSubroutineuiv( shadertype, location, params );
	FL_GL_ERROR_TRAP( "glGetUniformSubroutineuiv" );
}
inline void GetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint * values )
{
	glGetProgramStageiv( program, shadertype, pname, values );
	FL_GL_ERROR_TRAP( "glGetProgramStageiv" );
}
inline void PatchParameteri( GLenum pname, GLint value )
{
	glPatchParameteri( pname, value );
	FL_GL_ERROR_TRAP( "glPatchParameteri" );
}
inline void PatchParameterfv( GLenum pname, const GLfloat * values )
{
	glPatchParameterfv( pname, values );
	FL_GL_ERROR_TRAP( "glPatchParameterfv" );
}
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 DrawTransformFeedback( GLenum mode, GLuint id )
{
	glDrawTransformFeedback( mode, id );
	FL_GL_ERROR_TRAP( "glDrawTransformFeedback" );
}
inline void DrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream )
{
	glDrawTransformFeedbackStream( mode, id, stream );
	FL_GL_ERROR_TRAP( "glDrawTransformFeedbackStream" );
}
inline void BeginQueryIndexed( GLenum target, GLuint index, GLuint id )
{
	glBeginQueryIndexed( target, index, id );
	FL_GL_ERROR_TRAP( "glBeginQueryIndexed" );
}
inline void EndQueryIndexed( GLenum target, GLuint index )
{
	glEndQueryIndexed( target, index );
	FL_GL_ERROR_TRAP( "glEndQueryIndexed" );
}
inline void GetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint * params )
{
	glGetQueryIndexediv( target, index, pname, params );
	FL_GL_ERROR_TRAP( "glGetQueryIndexediv" );
}
// GL_VERSION_4_1
inline void ReleaseShaderCompiler( )
{
	glReleaseShaderCompiler( );
	FL_GL_ERROR_TRAP( "glReleaseShaderCompiler" );
}
inline void ShaderBinary( GLsizei count, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length )
{
	glShaderBinary( count, shaders, binaryformat, binary, length );
	FL_GL_ERROR_TRAP( "glShaderBinary" );
}
inline void GetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision )
{
	glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision );
	FL_GL_ERROR_TRAP( "glGetShaderPrecisionFormat" );
}
inline void DepthRangef( GLfloat n, GLfloat f )
{
	glDepthRangef( n, f );
	FL_GL_ERROR_TRAP( "glDepthRangef" );
}
inline void ClearDepthf( GLfloat d )
{
	glClearDepthf( d );
	FL_GL_ERROR_TRAP( "glClearDepthf" );
}
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 UseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program )
{
	glUseProgramStages( pipeline, stages, program );
	FL_GL_ERROR_TRAP( "glUseProgramStages" );
}
inline void ActiveShaderProgram( GLuint pipeline, GLuint program )
{
	glActiveShaderProgram( pipeline, program );
	FL_GL_ERROR_TRAP( "glActiveShaderProgram" );
}
inline GLuint CreateShaderProgramv( GLenum type, GLsizei count, const GLchar * const * strings )
{
	GLuint ret= glCreateShaderProgramv( type, count, strings );
	FL_GL_ERROR_TRAP( "glCreateShaderProgramv" );
	return	ret;
}
inline void BindProgramPipeline( GLuint pipeline )
{
	glBindProgramPipeline( pipeline );
	FL_GL_ERROR_TRAP( "glBindProgramPipeline" );
}
inline void DeleteProgramPipelines( GLsizei n, const GLuint * pipelines )
{
	glDeleteProgramPipelines( n, pipelines );
	FL_GL_ERROR_TRAP( "glDeleteProgramPipelines" );
}
inline void GenProgramPipelines( GLsizei n, GLuint * pipelines )
{
	glGenProgramPipelines( n, pipelines );
	FL_GL_ERROR_TRAP( "glGenProgramPipelines" );
}
inline GLboolean IsProgramPipeline( GLuint pipeline )
{
	GLboolean ret= glIsProgramPipeline( pipeline );
	FL_GL_ERROR_TRAP( "glIsProgramPipeline" );
	return	ret;
}
inline void GetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint * params )
{
	glGetProgramPipelineiv( pipeline, pname, params );
	FL_GL_ERROR_TRAP( "glGetProgramPipelineiv" );
}
inline void ProgramUniform1i( GLuint program, GLint location, GLint v0 )
{
	glProgramUniform1i( program, location, v0 );
	FL_GL_ERROR_TRAP( "glProgramUniform1i" );
}
inline void ProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint * value )
{
	glProgramUniform1iv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform1iv" );
}
inline void ProgramUniform1f( GLuint program, GLint location, GLfloat v0 )
{
	glProgramUniform1f( program, location, v0 );
	FL_GL_ERROR_TRAP( "glProgramUniform1f" );
}
inline void ProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat * value )
{
	glProgramUniform1fv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform1fv" );
}
inline void ProgramUniform1d( GLuint program, GLint location, GLdouble v0 )
{
	glProgramUniform1d( program, location, v0 );
	FL_GL_ERROR_TRAP( "glProgramUniform1d" );
}
inline void ProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble * value )
{
	glProgramUniform1dv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform1dv" );
}
inline void ProgramUniform1ui( GLuint program, GLint location, GLuint v0 )
{
	glProgramUniform1ui( program, location, v0 );
	FL_GL_ERROR_TRAP( "glProgramUniform1ui" );
}
inline void ProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint * value )
{
	glProgramUniform1uiv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform1uiv" );
}
inline void ProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 )
{
	glProgramUniform2i( program, location, v0, v1 );
	FL_GL_ERROR_TRAP( "glProgramUniform2i" );
}
inline void ProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint * value )
{
	glProgramUniform2iv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform2iv" );
}
inline void ProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 )
{
	glProgramUniform2f( program, location, v0, v1 );
	FL_GL_ERROR_TRAP( "glProgramUniform2f" );
}
inline void ProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat * value )
{
	glProgramUniform2fv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform2fv" );
}
inline void ProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 )
{
	glProgramUniform2d( program, location, v0, v1 );
	FL_GL_ERROR_TRAP( "glProgramUniform2d" );
}
inline void ProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble * value )
{
	glProgramUniform2dv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform2dv" );
}
inline void ProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 )
{
	glProgramUniform2ui( program, location, v0, v1 );
	FL_GL_ERROR_TRAP( "glProgramUniform2ui" );
}
inline void ProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint * value )
{
	glProgramUniform2uiv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform2uiv" );
}
inline void ProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 )
{
	glProgramUniform3i( program, location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glProgramUniform3i" );
}
inline void ProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint * value )
{
	glProgramUniform3iv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform3iv" );
}
inline void ProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
	glProgramUniform3f( program, location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glProgramUniform3f" );
}
inline void ProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat * value )
{
	glProgramUniform3fv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform3fv" );
}
inline void ProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 )
{
	glProgramUniform3d( program, location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glProgramUniform3d" );
}
inline void ProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble * value )
{
	glProgramUniform3dv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform3dv" );
}
inline void ProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
	glProgramUniform3ui( program, location, v0, v1, v2 );
	FL_GL_ERROR_TRAP( "glProgramUniform3ui" );
}
inline void ProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint * value )
{
	glProgramUniform3uiv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform3uiv" );
}
inline void ProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
	glProgramUniform4i( program, location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glProgramUniform4i" );
}
inline void ProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint * value )
{
	glProgramUniform4iv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform4iv" );
}
inline void ProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
	glProgramUniform4f( program, location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glProgramUniform4f" );
}
inline void ProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat * value )
{
	glProgramUniform4fv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform4fv" );
}
inline void ProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 )
{
	glProgramUniform4d( program, location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glProgramUniform4d" );
}
inline void ProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble * value )
{
	glProgramUniform4dv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform4dv" );
}
inline void ProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
	glProgramUniform4ui( program, location, v0, v1, v2, v3 );
	FL_GL_ERROR_TRAP( "glProgramUniform4ui" );
}
inline void ProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint * value )
{
	glProgramUniform4uiv( program, location, count, value );
	FL_GL_ERROR_TRAP( "glProgramUniform4uiv" );
}
inline void ProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix2fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2fv" );
}
inline void ProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix3fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3fv" );
}
inline void ProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix4fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4fv" );
}
inline void ProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix2dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2dv" );
}
inline void ProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix3dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3dv" );
}
inline void ProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix4dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4dv" );
}
inline void ProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix2x3fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2x3fv" );
}
inline void ProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix3x2fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3x2fv" );
}
inline void ProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix2x4fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2x4fv" );
}
inline void ProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix4x2fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4x2fv" );
}
inline void ProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix3x4fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3x4fv" );
}
inline void ProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value )
{
	glProgramUniformMatrix4x3fv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4x3fv" );
}
inline void ProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix2x3dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2x3dv" );
}
inline void ProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix3x2dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3x2dv" );
}
inline void ProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix2x4dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix2x4dv" );
}
inline void ProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix4x2dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4x2dv" );
}
inline void ProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix3x4dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix3x4dv" );
}
inline void ProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value )
{
	glProgramUniformMatrix4x3dv( program, location, count, transpose, value );
	FL_GL_ERROR_TRAP( "glProgramUniformMatrix4x3dv" );
}
inline void ValidateProgramPipeline( GLuint pipeline )
{
	glValidateProgramPipeline( pipeline );
	FL_GL_ERROR_TRAP( "glValidateProgramPipeline" );
}
inline void GetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog )
{
	glGetProgramPipelineInfoLog( pipeline, bufSize, length, infoLog );
	FL_GL_ERROR_TRAP( "glGetProgramPipelineInfoLog" );
}
inline void VertexAttribL1d( GLuint index, GLdouble x )
{
	glVertexAttribL1d( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttribL1d" );
}
inline void VertexAttribL2d( GLuint index, GLdouble x, GLdouble y )
{
	glVertexAttribL2d( index, x, y );
	FL_GL_ERROR_TRAP( "glVertexAttribL2d" );
}
inline void VertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
	glVertexAttribL3d( index, x, y, z );
	FL_GL_ERROR_TRAP( "glVertexAttribL3d" );
}
inline void VertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
	glVertexAttribL4d( index, x, y, z, w );
	FL_GL_ERROR_TRAP( "glVertexAttribL4d" );
}
inline void VertexAttribL1dv( GLuint index, const GLdouble * v )
{
	glVertexAttribL1dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribL1dv" );
}
inline void VertexAttribL2dv( GLuint index, const GLdouble * v )
{
	glVertexAttribL2dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribL2dv" );
}
inline void VertexAttribL3dv( GLuint index, const GLdouble * v )
{
	glVertexAttribL3dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribL3dv" );
}
inline void VertexAttribL4dv( GLuint index, const GLdouble * v )
{
	glVertexAttribL4dv( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribL4dv" );
}
inline void VertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer )
{
	glVertexAttribLPointer( index, size, type, stride, pointer );
	FL_GL_ERROR_TRAP( "glVertexAttribLPointer" );
}
inline void GetVertexAttribLdv( GLuint index, GLenum pname, GLdouble * params )
{
	glGetVertexAttribLdv( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribLdv" );
}
inline void ViewportArrayv( GLuint first, GLsizei count, const GLfloat * v )
{
	glViewportArrayv( first, count, v );
	FL_GL_ERROR_TRAP( "glViewportArrayv" );
}
inline void ViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h )
{
	glViewportIndexedf( index, x, y, w, h );
	FL_GL_ERROR_TRAP( "glViewportIndexedf" );
}
inline void ViewportIndexedfv( GLuint index, const GLfloat * v )
{
	glViewportIndexedfv( index, v );
	FL_GL_ERROR_TRAP( "glViewportIndexedfv" );
}
inline void ScissorArrayv( GLuint first, GLsizei count, const GLint * v )
{
	glScissorArrayv( first, count, v );
	FL_GL_ERROR_TRAP( "glScissorArrayv" );
}
inline void ScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height )
{
	glScissorIndexed( index, left, bottom, width, height );
	FL_GL_ERROR_TRAP( "glScissorIndexed" );
}
inline void ScissorIndexedv( GLuint index, const GLint * v )
{
	glScissorIndexedv( index, v );
	FL_GL_ERROR_TRAP( "glScissorIndexedv" );
}
inline void DepthRangeArrayv( GLuint first, GLsizei count, const GLdouble * v )
{
	glDepthRangeArrayv( first, count, v );
	FL_GL_ERROR_TRAP( "glDepthRangeArrayv" );
}
inline void DepthRangeIndexed( GLuint index, GLdouble n, GLdouble f )
{
	glDepthRangeIndexed( index, n, f );
	FL_GL_ERROR_TRAP( "glDepthRangeIndexed" );
}
inline void GetFloati_v( GLenum target, GLuint index, GLfloat * data )
{
	glGetFloati_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetFloati_v" );
}
inline void GetDoublei_v( GLenum target, GLuint index, GLdouble * data )
{
	glGetDoublei_v( target, index, data );
	FL_GL_ERROR_TRAP( "glGetDoublei_v" );
}
// GL_VERSION_4_2
inline void DrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance )
{
	glDrawArraysInstancedBaseInstance( mode, first, count, instancecount, baseinstance );
	FL_GL_ERROR_TRAP( "glDrawArraysInstancedBaseInstance" );
}
inline void DrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance )
{
	glDrawElementsInstancedBaseInstance( mode, count, type, indices, instancecount, baseinstance );
	FL_GL_ERROR_TRAP( "glDrawElementsInstancedBaseInstance" );
}
inline void DrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance )
{
	glDrawElementsInstancedBaseVertexBaseInstance( mode, count, type, indices, instancecount, basevertex, baseinstance );
	FL_GL_ERROR_TRAP( "glDrawElementsInstancedBaseVertexBaseInstance" );
}
inline void GetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params )
{
	glGetInternalformati64v( target, internalformat, pname, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetInternalformati64v" );
}
inline void GetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint * params )
{
	glGetActiveAtomicCounterBufferiv( program, bufferIndex, pname, params );
	FL_GL_ERROR_TRAP( "glGetActiveAtomicCounterBufferiv" );
}
inline void BindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format )
{
	glBindImageTexture( unit, texture, level, layered, layer, access, format );
	FL_GL_ERROR_TRAP( "glBindImageTexture" );
}
inline void MemoryBarrier( GLbitfield barriers )
{
	glMemoryBarrier( barriers );
	FL_GL_ERROR_TRAP( "glMemoryBarrier" );
}
inline void TexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width )
{
	glTexStorage1D( target, levels, internalformat, width );
	FL_GL_ERROR_TRAP( "glTexStorage1D" );
}
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 DrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei instancecount )
{
	glDrawTransformFeedbackInstanced( mode, id, instancecount );
	FL_GL_ERROR_TRAP( "glDrawTransformFeedbackInstanced" );
}
inline void DrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount )
{
	glDrawTransformFeedbackStreamInstanced( mode, id, stream, instancecount );
	FL_GL_ERROR_TRAP( "glDrawTransformFeedbackStreamInstanced" );
}
// GL_VERSION_4_3
inline void ClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data )
{
	glClearBufferData( target, internalformat, format, type, data );
	FL_GL_ERROR_TRAP( "glClearBufferData" );
}
inline void ClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data )
{
	glClearBufferSubData( target, internalformat, offset, size, format, type, data );
	FL_GL_ERROR_TRAP( "glClearBufferSubData" );
}
inline void DispatchCompute( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z )
{
	glDispatchCompute( num_groups_x, num_groups_y, num_groups_z );
	FL_GL_ERROR_TRAP( "glDispatchCompute" );
}
inline void DispatchComputeIndirect( GLintptr indirect )
{
	glDispatchComputeIndirect( indirect );
	FL_GL_ERROR_TRAP( "glDispatchComputeIndirect" );
}
inline void CopyImageSubData( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth )
{
	glCopyImageSubData( srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
	FL_GL_ERROR_TRAP( "glCopyImageSubData" );
}
inline void FramebufferParameteri( GLenum target, GLenum pname, GLint param )
{
	glFramebufferParameteri( target, pname, param );
	FL_GL_ERROR_TRAP( "glFramebufferParameteri" );
}
inline void GetFramebufferParameteriv( GLenum target, GLenum pname, GLint * params )
{
	glGetFramebufferParameteriv( target, pname, params );
	FL_GL_ERROR_TRAP( "glGetFramebufferParameteriv" );
}
inline void InvalidateTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth )
{
	glInvalidateTexSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth );
	FL_GL_ERROR_TRAP( "glInvalidateTexSubImage" );
}
inline void InvalidateTexImage( GLuint texture, GLint level )
{
	glInvalidateTexImage( texture, level );
	FL_GL_ERROR_TRAP( "glInvalidateTexImage" );
}
inline void InvalidateBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr length )
{
	glInvalidateBufferSubData( buffer, offset, length );
	FL_GL_ERROR_TRAP( "glInvalidateBufferSubData" );
}
inline void InvalidateBufferData( GLuint buffer )
{
	glInvalidateBufferData( buffer );
	FL_GL_ERROR_TRAP( "glInvalidateBufferData" );
}
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 MultiDrawArraysIndirect( GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride )
{
	glMultiDrawArraysIndirect( mode, indirect, drawcount, stride );
	FL_GL_ERROR_TRAP( "glMultiDrawArraysIndirect" );
}
inline void MultiDrawElementsIndirect( GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride )
{
	glMultiDrawElementsIndirect( mode, type, indirect, drawcount, stride );
	FL_GL_ERROR_TRAP( "glMultiDrawElementsIndirect" );
}
inline void GetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint * params )
{
	glGetProgramInterfaceiv( program, programInterface, pname, params );
	FL_GL_ERROR_TRAP( "glGetProgramInterfaceiv" );
}
inline GLuint GetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar * name )
{
	GLuint ret= glGetProgramResourceIndex( program, programInterface, name );
	FL_GL_ERROR_TRAP( "glGetProgramResourceIndex" );
	return	ret;
}
inline void GetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name )
{
	glGetProgramResourceName( program, programInterface, index, bufSize, length, name );
	FL_GL_ERROR_TRAP( "glGetProgramResourceName" );
}
inline void GetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params )
{
	glGetProgramResourceiv( program, programInterface, index, propCount, props, bufSize, length, params );
	FL_GL_ERROR_TRAP( "glGetProgramResourceiv" );
}
inline GLint GetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar * name )
{
	GLint ret= glGetProgramResourceLocation( program, programInterface, name );
	FL_GL_ERROR_TRAP( "glGetProgramResourceLocation" );
	return	ret;
}
inline GLint GetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar * name )
{
	GLint ret= glGetProgramResourceLocationIndex( program, programInterface, name );
	FL_GL_ERROR_TRAP( "glGetProgramResourceLocationIndex" );
	return	ret;
}
inline void ShaderStorageBlockBinding( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding )
{
	glShaderStorageBlockBinding( program, storageBlockIndex, storageBlockBinding );
	FL_GL_ERROR_TRAP( "glShaderStorageBlockBinding" );
}
inline void TexBufferRange( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
	glTexBufferRange( target, internalformat, buffer, offset, size );
	FL_GL_ERROR_TRAP( "glTexBufferRange" );
}
inline void TexStorage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
	glTexStorage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations );
	FL_GL_ERROR_TRAP( "glTexStorage2DMultisample" );
}
inline void TexStorage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
	glTexStorage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations );
	FL_GL_ERROR_TRAP( "glTexStorage3DMultisample" );
}
inline void TextureView( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers )
{
	glTextureView( texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers );
	FL_GL_ERROR_TRAP( "glTextureView" );
}
inline void BindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
{
	glBindVertexBuffer( bindingindex, buffer, offset, stride );
	FL_GL_ERROR_TRAP( "glBindVertexBuffer" );
}
inline void VertexAttribFormat( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
{
	glVertexAttribFormat( attribindex, size, type, normalized, relativeoffset );
	FL_GL_ERROR_TRAP( "glVertexAttribFormat" );
}
inline void VertexAttribIFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
	glVertexAttribIFormat( attribindex, size, type, relativeoffset );
	FL_GL_ERROR_TRAP( "glVertexAttribIFormat" );
}
inline void VertexAttribLFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
	glVertexAttribLFormat( attribindex, size, type, relativeoffset );
	FL_GL_ERROR_TRAP( "glVertexAttribLFormat" );
}
inline void VertexAttribBinding( GLuint attribindex, GLuint bindingindex )
{
	glVertexAttribBinding( attribindex, bindingindex );
	FL_GL_ERROR_TRAP( "glVertexAttribBinding" );
}
inline void VertexBindingDivisor( GLuint bindingindex, GLuint divisor )
{
	glVertexBindingDivisor( bindingindex, divisor );
	FL_GL_ERROR_TRAP( "glVertexBindingDivisor" );
}
inline void DebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled )
{
	glDebugMessageControl( source, type, severity, count, ids, enabled );
	FL_GL_ERROR_TRAP( "glDebugMessageControl" );
}
inline void DebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf )
{
	glDebugMessageInsert( source, type, id, severity, length, buf );
	FL_GL_ERROR_TRAP( "glDebugMessageInsert" );
}
inline void DebugMessageCallback( GLDEBUGPROC callback, const void * userParam )
{
	glDebugMessageCallback( callback, userParam );
	FL_GL_ERROR_TRAP( "glDebugMessageCallback" );
}
inline GLuint GetDebugMessageLog( GLuint count, GLsizei bufsize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog )
{
	GLuint ret= glGetDebugMessageLog( count, bufsize, sources, types, ids, severities, lengths, messageLog );
	FL_GL_ERROR_TRAP( "glGetDebugMessageLog" );
	return	ret;
}
inline void PushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar * message )
{
	glPushDebugGroup( source, id, length, message );
	FL_GL_ERROR_TRAP( "glPushDebugGroup" );
}
inline void PopDebugGroup( )
{
	glPopDebugGroup( );
	FL_GL_ERROR_TRAP( "glPopDebugGroup" );
}
inline void ObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar * label )
{
	glObjectLabel( identifier, name, length, label );
	FL_GL_ERROR_TRAP( "glObjectLabel" );
}
inline void GetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label )
{
	glGetObjectLabel( identifier, name, bufSize, length, label );
	FL_GL_ERROR_TRAP( "glGetObjectLabel" );
}
inline void ObjectPtrLabel( const void * ptr, GLsizei length, const GLchar * label )
{
	glObjectPtrLabel( ptr, length, label );
	FL_GL_ERROR_TRAP( "glObjectPtrLabel" );
}
inline void GetObjectPtrLabel( const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label )
{
	glGetObjectPtrLabel( ptr, bufSize, length, label );
	FL_GL_ERROR_TRAP( "glGetObjectPtrLabel" );
}
// GL_VERSION_4_4
inline void BufferStorage( GLenum target, GLsizeiptr size, const void * data, GLbitfield flags )
{
	glBufferStorage( target, size, data, flags );
	FL_GL_ERROR_TRAP( "glBufferStorage" );
}
inline void ClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void * data )
{
	glClearTexImage( texture, level, format, type, data );
	FL_GL_ERROR_TRAP( "glClearTexImage" );
}
inline void ClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data )
{
	glClearTexSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data );
	FL_GL_ERROR_TRAP( "glClearTexSubImage" );
}
inline void BindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint * buffers )
{
	glBindBuffersBase( target, first, count, buffers );
	FL_GL_ERROR_TRAP( "glBindBuffersBase" );
}
inline void BindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes )
{
	glBindBuffersRange( target, first, count, buffers, offsets, sizes );
	FL_GL_ERROR_TRAP( "glBindBuffersRange" );
}
inline void BindTextures( GLuint first, GLsizei count, const GLuint * textures )
{
	glBindTextures( first, count, textures );
	FL_GL_ERROR_TRAP( "glBindTextures" );
}
inline void BindSamplers( GLuint first, GLsizei count, const GLuint * samplers )
{
	glBindSamplers( first, count, samplers );
	FL_GL_ERROR_TRAP( "glBindSamplers" );
}
inline void BindImageTextures( GLuint first, GLsizei count, const GLuint * textures )
{
	glBindImageTextures( first, count, textures );
	FL_GL_ERROR_TRAP( "glBindImageTextures" );
}
inline void BindVertexBuffers( GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides )
{
	glBindVertexBuffers( first, count, buffers, offsets, strides );
	FL_GL_ERROR_TRAP( "glBindVertexBuffers" );
}
// GL_ARB_ES2_compatibility
// GL_ARB_ES3_compatibility
// GL_ARB_arrays_of_arrays
// GL_ARB_base_instance
// GL_ARB_bindless_texture
inline GLuint64 GetTextureHandleARB( GLuint texture )
{
	GLuint64 ret= glGetTextureHandleARB( texture );
	FL_GL_ERROR_TRAP( "glGetTextureHandleARB" );
	return	ret;
}
inline GLuint64 GetTextureSamplerHandleARB( GLuint texture, GLuint sampler )
{
	GLuint64 ret= glGetTextureSamplerHandleARB( texture, sampler );
	FL_GL_ERROR_TRAP( "glGetTextureSamplerHandleARB" );
	return	ret;
}
inline void MakeTextureHandleResidentARB( GLuint64 handle )
{
	glMakeTextureHandleResidentARB( handle );
	FL_GL_ERROR_TRAP( "glMakeTextureHandleResidentARB" );
}
inline void MakeTextureHandleNonResidentARB( GLuint64 handle )
{
	glMakeTextureHandleNonResidentARB( handle );
	FL_GL_ERROR_TRAP( "glMakeTextureHandleNonResidentARB" );
}
inline GLuint64 GetImageHandleARB( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format )
{
	GLuint64 ret= glGetImageHandleARB( texture, level, layered, layer, format );
	FL_GL_ERROR_TRAP( "glGetImageHandleARB" );
	return	ret;
}
inline void MakeImageHandleResidentARB( GLuint64 handle, GLenum access )
{
	glMakeImageHandleResidentARB( handle, access );
	FL_GL_ERROR_TRAP( "glMakeImageHandleResidentARB" );
}
inline void MakeImageHandleNonResidentARB( GLuint64 handle )
{
	glMakeImageHandleNonResidentARB( handle );
	FL_GL_ERROR_TRAP( "glMakeImageHandleNonResidentARB" );
}
inline void UniformHandleui64ARB( GLint location, GLuint64 value )
{
	glUniformHandleui64ARB( location, value );
	FL_GL_ERROR_TRAP( "glUniformHandleui64ARB" );
}
inline void UniformHandleui64vARB( GLint location, GLsizei count, const GLuint64 * value )
{
	glUniformHandleui64vARB( location, count, value );
	FL_GL_ERROR_TRAP( "glUniformHandleui64vARB" );
}
inline void ProgramUniformHandleui64ARB( GLuint program, GLint location, GLuint64 value )
{
	glProgramUniformHandleui64ARB( program, location, value );
	FL_GL_ERROR_TRAP( "glProgramUniformHandleui64ARB" );
}
inline void ProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 * values )
{
	glProgramUniformHandleui64vARB( program, location, count, values );
	FL_GL_ERROR_TRAP( "glProgramUniformHandleui64vARB" );
}
inline GLboolean IsTextureHandleResidentARB( GLuint64 handle )
{
	GLboolean ret= glIsTextureHandleResidentARB( handle );
	FL_GL_ERROR_TRAP( "glIsTextureHandleResidentARB" );
	return	ret;
}
inline GLboolean IsImageHandleResidentARB( GLuint64 handle )
{
	GLboolean ret= glIsImageHandleResidentARB( handle );
	FL_GL_ERROR_TRAP( "glIsImageHandleResidentARB" );
	return	ret;
}
inline void VertexAttribL1ui64ARB( GLuint index, GLuint64EXT x )
{
	glVertexAttribL1ui64ARB( index, x );
	FL_GL_ERROR_TRAP( "glVertexAttribL1ui64ARB" );
}
inline void VertexAttribL1ui64vARB( GLuint index, const GLuint64EXT * v )
{
	glVertexAttribL1ui64vARB( index, v );
	FL_GL_ERROR_TRAP( "glVertexAttribL1ui64vARB" );
}
inline void GetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT * params )
{
	glGetVertexAttribLui64vARB( index, pname, params );
	FL_GL_ERROR_TRAP( "glGetVertexAttribLui64vARB" );
}
// GL_ARB_blend_func_extended
// GL_ARB_buffer_storage
// GL_ARB_cl_event
inline GLsync CreateSyncFromCLeventARB( struct _cl_context * context, struct _cl_event * event, GLbitfield flags )
{
	GLsync ret= glCreateSyncFromCLeventARB( context, event, flags );
	FL_GL_ERROR_TRAP( "glCreateSyncFromCLeventARB" );
	return	ret;
}
// GL_ARB_clear_buffer_object
// GL_ARB_clear_texture
// GL_ARB_compressed_texture_pixel_storage
// GL_ARB_compute_shader
// GL_ARB_compute_variable_group_size
inline void DispatchComputeGroupSizeARB( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z )
{
	glDispatchComputeGroupSizeARB( num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z );
	FL_GL_ERROR_TRAP( "glDispatchComputeGroupSizeARB" );
}
// GL_ARB_conservative_depth
// GL_ARB_copy_buffer
// GL_ARB_copy_image
// GL_ARB_debug_output
inline void DebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled )
{
	glDebugMessageControlARB( source, type, severity, count, ids, enabled );
	FL_GL_ERROR_TRAP( "glDebugMessageControlARB" );
}
inline void DebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf )
{
	glDebugMessageInsertARB( source, type, id, severity, length, buf );
	FL_GL_ERROR_TRAP( "glDebugMessageInsertARB" );
}
inline void DebugMessageCallbackARB( GLDEBUGPROCARB callback, const void * userParam )
{
	glDebugMessageCallbackARB( callback, userParam );
	FL_GL_ERROR_TRAP( "glDebugMessageCallbackARB" );
}
inline GLuint GetDebugMessageLogARB( GLuint count, GLsizei bufsize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog )
{
	GLuint ret= glGetDebugMessageLogARB( count, bufsize, sources, types, ids, severities, lengths, messageLog );
	FL_GL_ERROR_TRAP( "glGetDebugMessageLogARB" );
	return	ret;
}
// GL_ARB_depth_buffer_float
// GL_ARB_depth_clamp
// GL_ARB_draw_buffers_blend
inline void BlendEquationiARB( GLuint buf, GLenum mode )
{
	glBlendEquationiARB( buf, mode );
	FL_GL_ERROR_TRAP( "glBlendEquationiARB" );
}
inline void BlendEquationSeparateiARB( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
{
	glBlendEquationSeparateiARB( buf, modeRGB, modeAlpha );
	FL_GL_ERROR_TRAP( "glBlendEquationSeparateiARB" );
}
inline void BlendFunciARB( GLuint buf, GLenum src, GLenum dst )
{
	glBlendFunciARB( buf, src, dst );
	FL_GL_ERROR_TRAP( "glBlendFunciARB" );
}
inline void BlendFuncSeparateiARB( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
	glBlendFuncSeparateiARB( buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
	FL_GL_ERROR_TRAP( "glBlendFuncSeparateiARB" );
}
// GL_ARB_draw_elements_base_vertex
// GL_ARB_draw_indirect
// GL_ARB_enhanced_layouts
// GL_ARB_explicit_attrib_location
// GL_ARB_explicit_uniform_location
// GL_ARB_fragment_coord_conventions
// GL_ARB_fragment_layer_viewport
// GL_ARB_framebuffer_no_attachments
// GL_ARB_framebuffer_object
// GL_ARB_framebuffer_sRGB
// GL_ARB_get_program_binary
// GL_ARB_gpu_shader5
// GL_ARB_gpu_shader_fp64
// GL_ARB_half_float_vertex
// GL_ARB_imaging
// GL_ARB_indirect_parameters
inline void MultiDrawArraysIndirectCountARB( GLenum mode, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
	glMultiDrawArraysIndirectCountARB( mode, indirect, drawcount, maxdrawcount, stride );
	FL_GL_ERROR_TRAP( "glMultiDrawArraysIndirectCountARB" );
}
inline void MultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
	glMultiDrawElementsIndirectCountARB( mode, type, indirect, drawcount, maxdrawcount, stride );
	FL_GL_ERROR_TRAP( "glMultiDrawElementsIndirectCountARB" );
}
// GL_ARB_internalformat_query
inline void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params )
{
	glGetInternalformativ( target, internalformat, pname, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetInternalformativ" );
}
// GL_ARB_internalformat_query2
// GL_ARB_invalidate_subdata
// GL_ARB_map_buffer_alignment
// GL_ARB_map_buffer_range
// GL_ARB_multi_bind
// GL_ARB_multi_draw_indirect
// GL_ARB_occlusion_query2
// GL_ARB_program_interface_query
// GL_ARB_provoking_vertex
// GL_ARB_query_buffer_object
// GL_ARB_robust_buffer_access_behavior
// GL_ARB_robustness
inline GLenum GetGraphicsResetStatusARB( )
{
	GLenum ret= glGetGraphicsResetStatusARB( );
	FL_GL_ERROR_TRAP( "glGetGraphicsResetStatusARB" );
	return	ret;
}
inline void GetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid * img )
{
	glGetnTexImageARB( target, level, format, type, bufSize, img );
	FL_GL_ERROR_TRAP( "glGetnTexImageARB" );
}
inline void ReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid * data )
{
	glReadnPixelsARB( x, y, width, height, format, type, bufSize, data );
	FL_GL_ERROR_TRAP( "glReadnPixelsARB" );
}
inline void GetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, GLvoid * img )
{
	glGetnCompressedTexImageARB( target, lod, bufSize, img );
	FL_GL_ERROR_TRAP( "glGetnCompressedTexImageARB" );
}
inline void GetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat * params )
{
	glGetnUniformfvARB( program, location, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetnUniformfvARB" );
}
inline void GetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint * params )
{
	glGetnUniformivARB( program, location, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetnUniformivARB" );
}
inline void GetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint * params )
{
	glGetnUniformuivARB( program, location, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetnUniformuivARB" );
}
inline void GetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble * params )
{
	glGetnUniformdvARB( program, location, bufSize, params );
	FL_GL_ERROR_TRAP( "glGetnUniformdvARB" );
}
// GL_ARB_robustness_isolation
// GL_ARB_sample_shading
inline void MinSampleShadingARB( GLfloat value )
{
	glMinSampleShadingARB( value );
	FL_GL_ERROR_TRAP( "glMinSampleShadingARB" );
}
// GL_ARB_sampler_objects
// GL_ARB_seamless_cube_map
// GL_ARB_seamless_cubemap_per_texture
// GL_ARB_separate_shader_objects
// GL_ARB_shader_atomic_counters
// GL_ARB_shader_bit_encoding
// GL_ARB_shader_draw_parameters
// GL_ARB_shader_group_vote
// GL_ARB_shader_image_load_store
// GL_ARB_shader_image_size
// GL_ARB_shader_precision
// GL_ARB_shader_stencil_export
// GL_ARB_shader_storage_buffer_object
// GL_ARB_shader_subroutine
// GL_ARB_shading_language_420pack
// GL_ARB_shading_language_include
inline void NamedStringARB( GLenum type, GLint namelen, const GLchar * name, GLint stringlen, const GLchar * string )
{
	glNamedStringARB( type, namelen, name, stringlen, string );
	FL_GL_ERROR_TRAP( "glNamedStringARB" );
}
inline void DeleteNamedStringARB( GLint namelen, const GLchar * name )
{
	glDeleteNamedStringARB( namelen, name );
	FL_GL_ERROR_TRAP( "glDeleteNamedStringARB" );
}
inline void CompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar * const * path, const GLint * length )
{
	glCompileShaderIncludeARB( shader, count, path, length );
	FL_GL_ERROR_TRAP( "glCompileShaderIncludeARB" );
}
inline GLboolean IsNamedStringARB( GLint namelen, const GLchar * name )
{
	GLboolean ret= glIsNamedStringARB( namelen, name );
	FL_GL_ERROR_TRAP( "glIsNamedStringARB" );
	return	ret;
}
inline void GetNamedStringARB( GLint namelen, const GLchar * name, GLsizei bufSize, GLint * stringlen, GLchar * string )
{
	glGetNamedStringARB( namelen, name, bufSize, stringlen, string );
	FL_GL_ERROR_TRAP( "glGetNamedStringARB" );
}
inline void GetNamedStringivARB( GLint namelen, const GLchar * name, GLenum pname, GLint * params )
{
	glGetNamedStringivARB( namelen, name, pname, params );
	FL_GL_ERROR_TRAP( "glGetNamedStringivARB" );
}
// GL_ARB_shading_language_packing
// GL_ARB_sparse_texture
inline void TexPageCommitmentARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean resident )
{
	glTexPageCommitmentARB( target, level, xoffset, yoffset, zoffset, width, height, depth, resident );
	FL_GL_ERROR_TRAP( "glTexPageCommitmentARB" );
}
// GL_ARB_stencil_texturing
// GL_ARB_sync
// GL_ARB_tessellation_shader
// GL_ARB_texture_buffer_object_rgb32
// GL_ARB_texture_buffer_range
// GL_ARB_texture_compression_bptc
// GL_ARB_texture_compression_rgtc
// GL_ARB_texture_cube_map_array
// GL_ARB_texture_gather
// GL_ARB_texture_mirror_clamp_to_edge
// GL_ARB_texture_multisample
// GL_ARB_texture_query_levels
// GL_ARB_texture_query_lod
// GL_ARB_texture_rg
// GL_ARB_texture_rgb10_a2ui
// GL_ARB_texture_stencil8
// GL_ARB_texture_storage
// GL_ARB_texture_storage_multisample
// GL_ARB_texture_swizzle
// GL_ARB_texture_view
// GL_ARB_timer_query
// GL_ARB_transform_feedback2
// GL_ARB_transform_feedback3
// GL_ARB_transform_feedback_instanced
// GL_ARB_uniform_buffer_object
// GL_ARB_vertex_array_bgra
// GL_ARB_vertex_array_object
// GL_ARB_vertex_attrib_64bit
// GL_ARB_vertex_attrib_binding
// GL_ARB_vertex_type_10f_11f_11f_rev
// GL_ARB_vertex_type_2_10_10_10_rev
// GL_ARB_viewport_array
// GL_KHR_debug
// GL_KHR_texture_compression_astc_ldr
// total=587