rs_gl.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/rs_gl.h"
#include "renderstack/rs_log.h"


// #define RS_LOG_GL 1
#if defined(RS_LOG_GL)
#   define RS_LOG_GL_FUNCTION(A) rs_log_gl_function(A)
#else
#   define RS_LOG_GL_FUNCTION(A)
#endif

extern "C" {

void rs_log_gl_function(char const * a)
{
    rs_log("%s\n", a);
}

void rs_check_error()
{
    GLint status = glGetError();
    if(status != GL_NO_ERROR)
    {
        rs_log("%s\n ", rs_gl_enum_string(status));
        rs_log("");
    }
}

const char *rs_gl_enum_string(GLenum e)
{
    switch(e)
    {
        case GL_INVALID_ENUM      : return "GL_INVALID_ENUM";
        case GL_INVALID_VALUE     : return "GL_INVALID_VALUE";
        case GL_INVALID_OPERATION : return "GL_INVALID_OPERATION";
        case GL_STACK_OVERFLOW    : return "GL_STACK_OVERFLOW";
        case GL_STACK_UNDERFLOW   : return "GL_STACK_UNDERFLOW";
        case GL_OUT_OF_MEMORY     : return "GL_OUT_OF_MEMORY";

        case GL_BYTE              : return "GL_BYTE";
        case GL_UNSIGNED_BYTE     : return "GL_UNSIGNED_BYTE";
        case GL_SHORT             : return "GL_SHORT";
        case GL_UNSIGNED_SHORT    : return "GL_UNSIGNED_SHORT";
        case GL_INT               : return "GL_INT";
        case GL_UNSIGNED_INT      : return "GL_UNSIGNED_INT";
        case GL_FLOAT             : return "GL_FLOAT";
        case GL_2_BYTES           : return "GL_2_BYTES";
        case GL_3_BYTES           : return "GL_3_BYTES";
        case GL_4_BYTES           : return "GL_4_BYTES";
        case GL_DOUBLE            : return "GL_DOUBLE";
        case GL_FLOAT_VEC2        : return "GL_FLOAT_VEC2";
        case GL_FLOAT_VEC3        : return "GL_FLOAT_VEC3";
        case GL_FLOAT_VEC4        : return "GL_FLOAT_VEC4";
        case GL_INT_VEC2          : return "GL_INT_VEC2";
        case GL_INT_VEC3          : return "GL_INT_VEC3";
        case GL_INT_VEC4          : return "GL_INT_VEC4";
        case GL_BOOL              : return "GL_BOOL";
        case GL_BOOL_VEC2         : return "GL_BOOL_VEC2";
        case GL_BOOL_VEC3         : return "GL_BOOL_VEC3";
        case GL_BOOL_VEC4         : return "GL_BOOL_VEC4";
        case GL_FLOAT_MAT2        : return "GL_FLOAT_MAT2";
        case GL_FLOAT_MAT3        : return "GL_FLOAT_MAT3";
        case GL_FLOAT_MAT4        : return "GL_FLOAT_MAT4";
        case GL_SAMPLER_1D        : return "GL_SAMPLER_1D";
        case GL_SAMPLER_2D        : return "GL_SAMPLER_2D";
        case GL_SAMPLER_3D        : return "GL_SAMPLER_3D";
        case GL_SAMPLER_CUBE      : return "GL_SAMPLER_CUBE";
        case GL_SAMPLER_1D_SHADOW : return "GL_SAMPLER_1D_SHADOW";
        case GL_SAMPLER_2D_SHADOW : return "GL_SAMPLER_2D_SHADOW";

        case GL_FRAMEBUFFER_COMPLETE                     : return "GL_FRAMEBUFFER_COMPLETE";
        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT        : return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER       : return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER       : return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
        case GL_FRAMEBUFFER_UNSUPPORTED                  : return "GL_FRAMEBUFFER_UNSUPPORTED";

        case GL_NONE:                   return "GL_NONE";
        case GL_FRAMEBUFFER_DEFAULT:    return "GL_FRAMEBUFFER_DEFAULT";
        case GL_TEXTURE:                return "GL_TEXTURE";
        case GL_RENDERBUFFER:           return "GL_RENDERBUFFER";

        case GL_SIGNED_NORMALIZED       : return "GL_SIGNED_NORMALIZED";
        case GL_UNSIGNED_NORMALIZED     : return "GL_UNSIGNED_NORMALIZED";

        case GL_LINEAR                  : return "GL_LINEAR";
        case GL_SRGB                    : return "GL_SRGB";

        default: return "?"; 
    }
}

/*  GL 1.0 ... 1.1  */ 
/*  GL_H  */ 
void rs_gl_array_element(GLint i)
{
    RS_LOG_GL_FUNCTION(__FUNCTION__);
    glArrayElement(i);
    rs_check_error();
}
void rs_gl_bind_texture(GLenum target, GLuint texture)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindTexture(target, texture);
    rs_check_error();
}
void rs_gl_blend_func(GLenum sfactor, GLenum dfactor)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlendFunc(sfactor, dfactor);
    rs_check_error();
}
void rs_gl_clear(GLbitfield mask)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClear(mask);
    rs_check_error();
}
void rs_gl_clear_color(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearColor(red, green, blue, alpha);
    rs_check_error();
}
void rs_gl_clear_depth(GLclampd depth)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearDepth(depth);
    rs_check_error();
}
void rs_gl_clear_stencil(GLint s)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearStencil(s);
    rs_check_error();
}
void rs_gl_color_mask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glColorMask(red, green, blue, alpha);
    rs_check_error();
}
void rs_gl_copy_tex_image_1d(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyTexImage1D(target, level, internalFormat, x, y, width, border);
    rs_check_error();
}
void rs_gl_copy_tex_image_2d(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
    rs_check_error();
}
void rs_gl_copy_tex_sub_image_1d(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyTexSubImage1D(target, level, xoffset, x, y, width);
    rs_check_error();
}
void rs_gl_copy_tex_sub_image_2d(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
    rs_check_error();
}
void rs_gl_cull_face(GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCullFace(mode);
    rs_check_error();
}
void rs_gl_delete_textures(GLsizei n, const GLuint *textures)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteTextures(n, textures);
    rs_check_error();
}
void rs_gl_depth_func(GLenum func)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDepthFunc(func);
    rs_check_error();
}
void rs_gl_depth_mask(GLboolean flag)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDepthMask(flag);
    rs_check_error();
}
void rs_gl_depth_range(GLclampd zNear, GLclampd zFar)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDepthRange(zNear, zFar);
    rs_check_error();
}
void rs_gl_disable(GLenum cap)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDisable(cap);
    rs_check_error();
}
void rs_gl_draw_arrays(GLenum mode, GLint first, GLsizei count)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawArrays(mode, first, count);
    rs_check_error();
}
void rs_gl_draw_buffer(GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawBuffer(mode);
    rs_check_error();
}
void rs_gl_draw_elements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawElements(mode, count, type, indices);
    rs_check_error();
}
void rs_gl_enable(GLenum cap)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEnable(cap);
    rs_check_error();
}
void rs_gl_finish(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    rs_check_error();
}
void rs_gl_flush(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFlush();
    rs_check_error();
}
void rs_gl_front_face(GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFrontFace(mode);
    rs_check_error();
}
void rs_gl_gen_textures(GLsizei n, GLuint *textures)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenTextures(n, textures);
    rs_check_error();
}
void rs_gl_get_boolean_v(GLenum pname, GLboolean *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBooleanv(pname, params);
    rs_check_error();
}
void rs_gl_get_double_v(GLenum pname, GLdouble *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetDoublev(pname, params);
    rs_check_error();
}
GLenum rs_gl_get_error(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    return glGetError();
}
void rs_gl_get_float_v(GLenum pname, GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetFloatv(pname, params);
    rs_check_error();
}
void rs_gl_get_integer_v(GLenum pname, GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetIntegerv(pname, params);
    rs_check_error();
}
void rs_gl_get_pointer_v(GLenum pname, GLvoid* *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetPointerv(pname, params);
    rs_check_error();
}
const GLubyte * rs_gl_get_string(GLenum name)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    const GLubyte *res = glGetString(name);
    rs_check_error();
    return res;
}
void rs_gl_get_tex_env_fv(GLenum target, GLenum pname, GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexEnvfv(target, pname, params);
    rs_check_error();
}
void rs_gl_get_tex_env_iv(GLenum target, GLenum pname, GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexEnviv(target, pname, params);
    rs_check_error();
}
void rs_gl_get_tex_image(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexImage(target, level, format, type, pixels);
    rs_check_error();
}
void rs_gl_get_tex_level_parameter_fv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexLevelParameterfv(target, level, pname, params);
    rs_check_error();
}
void rs_gl_get_tex_level_parameter_iv(GLenum target, GLint level, GLenum pname, GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexLevelParameteriv(target, level, pname, params);
    rs_check_error();
}
void rs_gl_get_tex_parameter_fv(GLenum target, GLenum pname, GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexParameterfv(target, pname, params);
    rs_check_error();
}
void rs_gl_get_tex_parameter_iv(GLenum target, GLenum pname, GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexParameteriv(target, pname, params);
    rs_check_error();
}
void rs_gl_hint(GLenum target, GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glHint(target, mode);
    rs_check_error();
}
GLboolean rs_gl_is_enabled(GLenum cap)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsEnabled(cap);
    rs_check_error();
    return res;
}
GLboolean rs_gl_is_texture(GLuint texture)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsTexture(texture);
    rs_check_error();
    return res;
}
void rs_gl_line_width(GLfloat width)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glLineWidth(width);
    rs_check_error();
}
void rs_gl_logic_op(GLenum opcode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glLogicOp(opcode);
    rs_check_error();
}
void rs_gl_pixel_store_f(GLenum pname, GLfloat param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPixelStoref(pname, param);
    rs_check_error();
}
void rs_gl_pixel_store_i(GLenum pname, GLint param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPixelStorei(pname, param);
    rs_check_error();
}
void rs_gl_pixel_transfer_f(GLenum pname, GLfloat param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPixelTransferf(pname, param);
    rs_check_error();
}
void rs_gl_pixel_transfer_i(GLenum pname, GLint param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPixelTransferi(pname, param);
    rs_check_error();
}
void rs_gl_point_size(GLfloat size)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPointSize(size);
    rs_check_error();
}
void rs_gl_polygon_mode(GLenum face, GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPolygonMode(face, mode);
    rs_check_error();
}
void rs_gl_polygon_offset(GLfloat factor, GLfloat units)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPolygonOffset(factor, units);
    rs_check_error();
}
void rs_gl_read_buffer(GLenum mode)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glReadBuffer(mode);
    rs_check_error();
}
void rs_gl_read_pixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glReadPixels(x, y, width, height, format, type, pixels);
    rs_check_error();
}
void rs_gl_scissor(GLint x, GLint y, GLsizei width, GLsizei height)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glScissor(x, y, width, height);
    rs_check_error();
}
void rs_gl_stencil_func(GLenum func, GLint ref, GLuint mask)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilFunc(func, ref, mask);
    rs_check_error();
}
void rs_gl_stencil_mask(GLuint mask)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilMask(mask);
    rs_check_error();
}
void rs_gl_stencil_op(GLenum fail, GLenum zfail, GLenum zpass)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilOp(fail, zfail, zpass);
    rs_check_error();
}
void rs_gl_tex_env_f(GLenum target, GLenum pname, GLfloat param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexEnvf(target, pname, param);
    rs_check_error();
}
void rs_gl_tex_env_fv(GLenum target, GLenum pname, const GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexEnvfv(target, pname, params);
    rs_check_error();
}
void rs_gl_tex_env_i(GLenum target, GLenum pname, GLint param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexEnvi(target, pname, param);
    rs_check_error();
}
void rs_gl_tex_env_iv(GLenum target, GLenum pname, const GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexEnviv(target, pname, params);
    rs_check_error();
}
void rs_gl_tex_image_1d(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
    rs_check_error();
}
void rs_gl_tex_image_2d(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
    rs_check_error();
}
void rs_gl_tex_parameter_f(GLenum target, GLenum pname, GLfloat param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameterf(target, pname, param);
    rs_check_error();
}
void rs_gl_tex_parameter_fv(GLenum target, GLenum pname, const GLfloat *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameterfv(target, pname, params);
    rs_check_error();
}
void rs_gl_tex_parameter_i(GLenum target, GLenum pname, GLint param)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameteri(target, pname, param);
    rs_check_error();
}
void rs_gl_tex_parameter_iv(GLenum target, GLenum pname, const GLint *params)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameteriv(target, pname, params);
    rs_check_error();
}
void rs_gl_tex_sub_image_1d(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
    rs_check_error();
}
void rs_gl_tex_sub_image_2d(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
    rs_check_error();
}
void rs_gl_viewport(GLint x, GLint y, GLsizei width, GLsizei height)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glViewport(x, y, width, height);
    rs_check_error();
}

/*  GL_VERSION_1_2  */ 
void rs_gl_blend_color(GLclampf a, GLclampf b, GLclampf c, GLclampf d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlendColor(a, b, c, d);
    rs_check_error();
}

void rs_gl_blend_equation(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlendEquation(a);
    rs_check_error();
}

void rs_gl_draw_range_elements(GLenum a, GLuint b, GLuint c, GLsizei d, GLenum e, const GLvoid *f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawRangeElements(a, b, c, d, e, f);
    rs_check_error();
}

void rs_gl_tex_image_3d(GLenum a, GLint b, GLint c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLenum h, GLenum i, const GLvoid *j)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexImage3D(a, b, c, d, e, f, g, h, i, j);
    rs_check_error();
}

void rs_gl_tex_sub_image_3d(GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLenum j, const GLvoid *k)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexSubImage3D(a, b, c, d, e, f, g, h, i, j, k);
    rs_check_error();
}

void rs_gl_copy_tex_sub_image_3d(GLenum a, GLint b, GLint c, GLint d, GLint e, GLint f, GLint g, GLsizei h, GLsizei i)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyTexSubImage3D(a, b, c, d, e, f, g, h, i);
    rs_check_error();
}


/*  GL_VERSION_1_3  */ 
void rs_gl_active_texture(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glActiveTexture(a);
    rs_check_error();
}

void rs_gl_sample_coverage(GLclampf a, GLboolean b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glSampleCoverage(a, b);
    rs_check_error();
}

void rs_gl_compressed_tex_image_3d(GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLsizei h, const GLvoid *i)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexImage3D(a, b, c, d, e, f, g, h, i);
    rs_check_error();
}

void rs_gl_compressed_tex_image_2d(GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLint f, GLsizei g, const GLvoid *h)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexImage2D(a, b, c, d, e, f, g, h);
    rs_check_error();
}

void rs_gl_compressed_tex_image_1d(GLenum a, GLint b, GLenum c, GLsizei d, GLint e, GLsizei f, const GLvoid *g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexImage1D(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_compressed_tex_sub_image_3d(GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLsizei j, const GLvoid *k)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexSubImage3D(a, b, c, d, e, f, g, h, i, j, k);
    rs_check_error();
}

void rs_gl_compressed_tex_sub_image_2d(GLenum a, GLint b, GLint c, GLint d, GLsizei e, GLsizei f, GLenum g, GLsizei h, const GLvoid *i)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexSubImage2D(a, b, c, d, e, f, g, h, i);
    rs_check_error();
}

void rs_gl_compressed_tex_sub_image_1d(GLenum a, GLint b, GLint c, GLsizei d, GLenum e, GLsizei f, const GLvoid *g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompressedTexSubImage1D(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_get_compressed_tex_image(GLenum a, GLint b, GLvoid *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetCompressedTexImage(a, b, c);
    rs_check_error();
}


/*  GL_VERSION_1_4  */ 
void rs_gl_blend_func_separate(GLenum a, GLenum b, GLenum c, GLenum d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlendFuncSeparate(a, b, c, d);
    rs_check_error();
}

void rs_gl_multi_draw_arrays(GLenum a, GLint *b, GLsizei *c, GLsizei d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glMultiDrawArrays(a, b, c, d);
    rs_check_error();
}

void rs_gl_multi_draw_elements(GLenum a, const GLsizei *b, GLenum c, const GLvoid* *d, GLsizei e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glMultiDrawElements(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_point_parameter_f(GLenum a, GLfloat b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPointParameterf(a, b);
    rs_check_error();
}

void rs_gl_point_parameter_fv(GLenum a, const GLfloat *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPointParameterfv(a, b);
    rs_check_error();
}

void rs_gl_point_parameter_i(GLenum a, GLint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPointParameteri(a, b);
    rs_check_error();
}

void rs_gl_point_parameter_iv(GLenum a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPointParameteriv(a, b);
    rs_check_error();
}


/*  GL_VERSION_1_5  */ 
void rs_gl_gen_queries(GLsizei a, GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenQueries(a, b);
    rs_check_error();
}

void rs_gl_delete_queries(GLsizei a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteQueries(a, b);
    rs_check_error();
}

GLboolean rs_gl_is_query(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsQuery(a);
    rs_check_error();
    return res;
}

void rs_gl_begin_query(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBeginQuery(a, b);
    rs_check_error();
}

void rs_gl_end_query(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEndQuery(a);
    rs_check_error();
}

void rs_gl_get_query_iv(GLenum a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetQueryiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_query_object_iv(GLuint a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetQueryObjectiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_query_object_uiv(GLuint a, GLenum b, GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetQueryObjectuiv(a, b, c);
    rs_check_error();
}

void rs_gl_bind_buffer(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindBuffer(a, b);
    rs_check_error();
}

void rs_gl_delete_buffers(GLsizei a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteBuffers(a, b);
    rs_check_error();
}

void rs_gl_gen_buffers(GLsizei a, GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenBuffers(a, b);
    rs_check_error();
}

GLboolean rs_gl_is_buffer(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsBuffer(a);
    rs_check_error();
    return res;
}

void rs_gl_buffer_data(GLenum a, GLsizeiptr b, const GLvoid *c, GLenum d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBufferData(a, b, c, d);
    rs_check_error();
}

void rs_gl_buffer_sub_data(GLenum a, GLintptr b, GLsizeiptr c, const GLvoid *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBufferSubData(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_buffer_sub_data(GLenum a, GLintptr b, GLsizeiptr c, GLvoid *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBufferSubData(a, b, c, d);
    rs_check_error();
}

GLvoid* rs_gl_map_buffer(GLenum a, GLenum b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLvoid* res = glMapBuffer(a, b);
    rs_check_error();
    return res;
}

GLboolean rs_gl_unmap_buffer(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glUnmapBuffer(a);
    rs_check_error();
    return res;
}

void rs_gl_get_buffer_parameter_iv(GLenum a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBufferParameteriv(a, b, c);
    rs_check_error();
}

void rs_gl_get_buffer_pointer_v(GLenum a, GLenum b, GLvoid* *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBufferPointerv(a, b, c);
    rs_check_error();
}


/*  GL_VERSION_2_0  */ 
void rs_gl_blend_equation_separate(GLenum a, GLenum b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlendEquationSeparate(a, b);
    rs_check_error();
}

void rs_gl_draw_buffers(GLsizei a, const GLenum * b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawBuffers(a, b);
    rs_check_error();
}

void rs_gl_stencil_op_separate(GLenum a, GLenum b, GLenum c, GLenum d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilOpSeparate(a, b, c, d);
    rs_check_error();
}

void rs_gl_stencil_func_Separate(GLenum a, GLenum b, GLint c, GLuint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilFuncSeparate(a, b, c, d);
    rs_check_error();
}

void rs_gl_stencil_mask_separate(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glStencilMaskSeparate(a, b);
    rs_check_error();
}

void rs_gl_attach_shader(GLuint a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glAttachShader(a, b);
    rs_check_error();
}

void rs_gl_bind_attrib_location(GLuint a, GLuint b, const GLchar *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindAttribLocation(a, b, c);
    rs_check_error();
}

void rs_gl_compile_shader(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCompileShader(a);
    rs_check_error();
}

GLuint rs_gl_create_program(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLuint res = glCreateProgram();
    rs_check_error();
    return res;
}

GLuint rs_gl_create_shader(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLuint res = glCreateShader(a);
    rs_check_error();
    return res;
}

void rs_gl_delete_program(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteProgram(a);
    rs_check_error();
}

void rs_gl_delete_shader(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteShader(a);
    rs_check_error();
}

void rs_gl_detach_shader(GLuint a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDetachShader(a, b);
    rs_check_error();
}

void rs_gl_disable_vertex_attrib_array(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDisableVertexAttribArray(a);
    rs_check_error();
}

void rs_gl_enable_vertex_attrib_array(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEnableVertexAttribArray(a);
    rs_check_error();
}

void rs_gl_get_active_attrib(GLuint a, GLuint b, GLsizei c, GLsizei *d, GLint *e, GLenum *f, GLchar *g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetActiveAttrib(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_get_active_uniform(GLuint a, GLuint b, GLsizei c, GLsizei *d, GLint *e, GLenum *f, GLchar *g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetActiveUniform(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_get_attached_shaders(GLuint a, GLsizei b, GLsizei *c, GLuint *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetAttachedShaders(a, b, c, d);
    rs_check_error();
}

GLint rs_gl_get_attrib_location(GLuint a, const GLchar *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLint res = glGetAttribLocation(a, b);
    rs_check_error();
    return res;
}

void rs_gl_get_program_iv(GLuint a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetProgramiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_program_info_log(GLuint a, GLsizei b, GLsizei *c, GLchar *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetProgramInfoLog(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_shader_iv(GLuint a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetShaderiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_shader_info_log(GLuint a, GLsizei b, GLsizei *c, GLchar *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetShaderInfoLog(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_shader_source(GLuint a, GLsizei b, GLsizei *c, GLchar *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetShaderSource(a, b, c, d);
    rs_check_error();
}

GLint rs_gl_get_uniform_location(GLuint a, const GLchar *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLint res = glGetUniformLocation(a, b);
    rs_check_error();
    return res;
}

void rs_gl_get_uniform_fv(GLuint a, GLint b, GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetUniformfv(a, b, c);
    rs_check_error();
}


void rs_gl_get_uniform_iv(GLuint a, GLint b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetUniformiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_dv(GLuint a, GLenum b, GLdouble *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribdv(a, b, c);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_fv(GLuint a, GLenum b, GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribfv(a, b, c);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_iv(GLuint a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_pointer_v(GLuint a, GLenum b, GLvoid* *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribPointerv(a, b, c);
    rs_check_error();
}

GLboolean rs_gl_is_program(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsProgram(a);
    rs_check_error();
    return res;
}

GLboolean rs_gl_is_shader(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsShader(a);
    rs_check_error();
    return res;
}

void rs_gl_link_program(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glLinkProgram(a);
    rs_check_error();
}

void rs_gl_shader_source(GLuint a, GLsizei b, const GLchar* *c, const GLint *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glShaderSource(a, b, c, d);
    rs_check_error();
}

void rs_gl_use_program(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUseProgram(a);
    rs_check_error();
}

void rs_gl_uniform_1f(GLint a, GLfloat b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1f(a, b);
    rs_check_error();
}
void rs_gl_uniform_2f(GLint a, GLfloat b, GLfloat c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2f(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3f(GLint a, GLfloat b, GLfloat c, GLfloat d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3f(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_4f(GLint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4f(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_uniform_1i(GLint a, GLint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1i(a, b);
    rs_check_error();
}

void rs_gl_uniform_2i(GLint a, GLint b, GLint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2i(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3i(GLint a, GLint b, GLint c, GLint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3i(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_4i(GLint a, GLint b, GLint c, GLint d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4i(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_uniform_1fv(GLint a, GLsizei b, const GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1fv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_2fv(GLint a, GLsizei b, const GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2fv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3fv(GLint a, GLsizei b, const GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3fv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_4fv(GLint a, GLsizei b, const GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4fv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_1iv(GLint a, GLsizei b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1iv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_2iv(GLint a, GLsizei b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2iv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3iv(GLint a, GLsizei b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3iv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_4iv(GLint a, GLsizei b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4iv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_matrix_2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix2fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_3fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix3fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_4fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix4fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_validate_program(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glValidateProgram(a);
    rs_check_error();
}

void rs_gl_vertex_attrib_1d(GLuint a, GLdouble b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1d(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_1dv(GLuint a, const GLdouble *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1dv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_1f(GLuint a, GLfloat b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1f(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_1fv(GLuint a, const GLfloat *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1fv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_1s(GLuint a, GLshort b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1s(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_1sv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib1sv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_2d(GLuint a, GLdouble b, GLdouble c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2d(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_2dv(GLuint a, const GLdouble *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2dv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_2f(GLuint a, GLfloat b, GLfloat c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2f(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_2fv(GLuint a, const GLfloat *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2fv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_2s(GLuint a, GLshort b, GLshort c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2s(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_2sv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib2sv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_3d(GLuint a, GLdouble b, GLdouble c, GLdouble d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3d(a, b, c, d);
    rs_check_error();
}

void rs_gl_vertex_attrib_3dv(GLuint a, const GLdouble *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3dv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_3f(GLuint a, GLfloat b, GLfloat c, GLfloat d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3f(a, b, c, d);
    rs_check_error();
}

void rs_gl_vertex_attrib_3fv(GLuint a, const GLfloat *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3fv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_3s(GLuint a, GLshort b, GLshort c, GLshort d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3s(a, b, c, d);
    rs_check_error();
}

void rs_gl_vertex_attrib_3sv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib3sv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nbv(GLuint a, const GLbyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nbv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Niv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Niv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nsv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nsv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nub(GLuint a, GLubyte b, GLubyte c, GLubyte d, GLubyte e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nub(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nubv(GLuint a, const GLubyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nubv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nuiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nuiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4Nusv(GLuint a, const GLushort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4Nusv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4bv(GLuint a, const GLbyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4bv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4d(GLuint a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4d(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_4dv(GLuint a, const GLdouble *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4dv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4f(GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4f(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_4fv(GLuint a, const GLfloat *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4fv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4iv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4iv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4s(GLuint a, GLshort b, GLshort c, GLshort d, GLshort e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4s(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_4sv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4sv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4ubv(GLuint a, const GLubyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4ubv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4uiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4uiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_4usv(GLuint a, const GLushort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttrib4usv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_pointer(GLuint a, GLint b, GLenum c, GLboolean d, GLsizei e, const GLvoid *f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribPointer(a, b, c, d, e, f);
    rs_check_error();
}

/*  GL_VERSION_2_1  */ 
void rs_gl_uniform_matrix_2x3fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix2x3fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_3x2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix3x2fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_niform_matrix_2x4fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix2x4fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_4x2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix4x2fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_3x4fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix3x4fv(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_matrix_4x3fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniformMatrix4x3fv(a, b, c, d);
    rs_check_error();
}


/*  GL_VERSION_3_0  */ 
void rs_gl_color_mask_i(GLuint a, GLboolean b, GLboolean c, GLboolean d, GLboolean e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glColorMaski(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_get_boolean_i_v(GLenum a, GLuint b, GLboolean *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBooleani_v(a, b, c);
    rs_check_error();
}

void rs_gl_get_integer_i_v (GLenum a, GLuint b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetIntegeri_v(a, b, c);
    rs_check_error();
}

void rs_gl_enable_i(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEnablei(a, b);
    rs_check_error();
}

void rs_gl_disable_i(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDisablei(a, b);
    rs_check_error();
}

GLboolean rs_gl_is_enabled_i(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsEnabledi(a, b);
    rs_check_error();
    return res;
}

void rs_gl_begin_transform_feedback(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBeginTransformFeedback(a);
    rs_check_error();
}

void rs_gl_end_transform_feedback(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEndTransformFeedback();
    rs_check_error();
}

void rs_gl_bind_buffer_range(GLenum a, GLuint b, GLuint c, GLintptr d, GLsizeiptr e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindBufferRange(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_bind_buffer_base(GLenum a, GLuint b, GLuint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindBufferBase(a, b, c);
    rs_check_error();
}

void rs_gl_transform_feedback_varyings(GLuint a, GLsizei b, const GLchar* *c, GLenum d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTransformFeedbackVaryings(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_transform_feedback_varying(GLuint a, GLuint b, GLsizei c, GLsizei *d, GLsizei *e, GLenum *f, GLchar *g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTransformFeedbackVarying(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_clamp_color(GLenum a, GLenum b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClampColor(a, b);
    rs_check_error();
}

void rs_gl_begin_conditional_render(GLuint a, GLenum b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBeginConditionalRender(a, b);
    rs_check_error();
}

void rs_gl_end_conditional_render(void)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glEndConditionalRender();
    rs_check_error();
}

void rs_gl_vertex_attrib_i_pointer(GLuint a, GLint b, GLenum c, GLsizei d, const GLvoid *e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribIPointer(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_iiv(GLuint a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribIiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_vertex_attrib_iuiv(GLuint a, GLenum b, GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetVertexAttribIuiv(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_i1i(GLuint a, GLint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI1i(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i2i(GLuint a, GLint b, GLint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI2i(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_i3i(GLuint a, GLint b, GLint c, GLint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI3i(a, b, c, d);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4i(GLuint a, GLint b, GLint c, GLint d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4i(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_i1ui(GLuint a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI1ui(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i2ui(GLuint a, GLuint b, GLuint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI2ui(a, b, c);
    rs_check_error();
}

void rs_gl_vertex_attrib_i3ui(GLuint a, GLuint b, GLuint c, GLuint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI3ui(a, b, c, d);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4ui(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4ui(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_vertex_attrib_i1iv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI1iv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i2iv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI2iv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i3iv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI3iv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4iv(GLuint a, const GLint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4iv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i1uiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI1uiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i2uiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI2uiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i3uiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI3uiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4uiv(GLuint a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4uiv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4bv(GLuint a, const GLbyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4bv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4sv(GLuint a, const GLshort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4sv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4ubv(GLuint a, const GLubyte *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4ubv(a, b);
    rs_check_error();
}

void rs_gl_vertex_attrib_i4usv(GLuint a, const GLushort *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glVertexAttribI4usv(a, b);
    rs_check_error();
}

void rs_gl_get_uniform_uiv(GLuint a, GLint b, GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetUniformuiv(a, b, c);
    rs_check_error();
}

void rs_gl_bind_frag_data_location(GLuint a, GLuint b, const GLchar *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindFragDataLocation(a, b, c);
    rs_check_error();
}

GLint rs_gl_get_frag_data_location(GLuint a, const GLchar *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLint res = glGetFragDataLocation(a, b);
    rs_check_error();
    return res;
}

void rs_gl_uniform_1ui(GLint a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1ui(a, b);
    rs_check_error();
}

void rs_gl_uniform_2ui(GLint a, GLuint b, GLuint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2ui(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3ui(GLint a, GLuint b, GLuint c, GLuint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3ui(a, b, c, d);
    rs_check_error();
}

void rs_gl_uniform_4ui(GLint a, GLuint b, GLuint c, GLuint d, GLuint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4ui(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_uniform_1uiv(GLint a, GLsizei b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform1uiv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_2uiv(GLint a, GLsizei b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform2uiv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_3uiv(GLint a, GLsizei b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform3uiv(a, b, c);
    rs_check_error();
}

void rs_gl_uniform_4uiv(GLint a, GLsizei b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glUniform4uiv(a, b, c);
    rs_check_error();
}

void rs_gl_tex_parameter_iiv(GLenum a, GLenum b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameterIiv(a, b, c);
    rs_check_error();
}

void rs_gl_tex_parameter_iuiv(GLenum a, GLenum b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexParameterIuiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_tex_parameter_iiv(GLenum a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexParameterIiv(a, b, c);
    rs_check_error();
}

void rs_gl_get_tex_parameter_iuiv(GLenum a, GLenum b, GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetTexParameterIuiv(a, b, c);
    rs_check_error();
}

void rs_gl_clear_buffer_iv(GLenum a, GLint b, const GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearBufferiv(a, b, c);
    rs_check_error();
}

void rs_gl_clear_buffer_uiv(GLenum a, GLint b, const GLuint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearBufferuiv(a, b, c);
    rs_check_error();
}

void rs_gl_clear_buffer_fv(GLenum a, GLint b, const GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearBufferfv(a, b, c);
    rs_check_error();
}

void rs_gl_clear_buffer_fi(GLenum a, GLint b, GLfloat c, GLint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glClearBufferfi(a, b, c, d);
    rs_check_error();
}

const GLubyte * rs_gl_get_string_i(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    const GLubyte * res = glGetStringi(a, b);
    rs_check_error();
    return res;
}


/*  GL_VERSION_3_1  */ 
void rs_gl_draw_arrays_instanced(GLenum a, GLint b, GLsizei c, GLsizei d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawArraysInstanced(a, b, c, d);
    rs_check_error();
}

void rs_gl_draw_elements_instanced(GLenum a, GLsizei b, GLenum c, const GLvoid *d, GLsizei e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawElementsInstanced(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_tex_buffer(GLenum a, GLenum b, GLuint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexBuffer(a, b, c);
    rs_check_error();
}

void rs_gl_primitive_restart_index(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glPrimitiveRestartIndex(a);
    rs_check_error();
}


/*  GL_VERSION_3_2  */ 
void rs_gl_get_integer_64i_v(GLenum a, GLuint b, GLint64 *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetInteger64i_v(a, b, c);
    rs_check_error();
}

void rs_gl_get_buffer_parameter_i64v(GLenum a, GLenum b, GLint64 *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetBufferParameteri64v(a, b, c);
    rs_check_error();
}

void rs_gl_program_parameter_i(GLuint a, GLenum b, GLint c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glProgramParameteri(a, b, c);
    rs_check_error();
}

void rs_gl_framebuffer_texture(GLenum a, GLenum b, GLuint c, GLint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTexture(a, b, c, d);
    rs_check_error();
}

void rs_gl_framebuffer_texture_face(GLenum a, GLenum b, GLuint c, GLint d, GLenum e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTextureFace(a, b, c, d, e);
    rs_check_error();
}

/*  3.0  */ 
/* ARB_framebuffer_object */ 
GLboolean rs_gl_is_renderbuffer(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsRenderbuffer(a);
    rs_check_error();
    return res;
}

void rs_gl_bind_renderbuffer(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindRenderbuffer(a, b);
    rs_check_error();
}

void rs_gl_delete_renderbuffers(GLsizei a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteRenderbuffers(a, b);
    rs_check_error();
}

void rs_gl_gen_renderbuffers(GLsizei a, GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenRenderbuffers(a, b);
    rs_check_error();
}

void rs_gl_renderbuffer_storage(GLenum a, GLenum b, GLsizei c, GLsizei d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glRenderbufferStorage(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_renderbuffer_parameter_iv(GLenum a, GLenum b, GLint *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetRenderbufferParameteriv(a, b, c);
    rs_check_error();
}

GLboolean rs_gl_is_framebuffer(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsFramebuffer(a);
    rs_check_error();
    return res;
}

void rs_gl_bind_framebuffer(GLenum a, GLuint b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindFramebuffer(a, b);
    rs_check_error();
}

void rs_gl_delete_framebuffers(GLsizei a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteFramebuffers(a, b);
    rs_check_error();
}

void rs_gl_gen_framebuffers(GLsizei a, GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenFramebuffers(a, b);
    rs_check_error();
}

GLenum rs_gl_check_framebuffer_status(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLenum res = glCheckFramebufferStatus(a);
    rs_check_error();
    return res;
}

void rs_gl_framebuffer_rexture_1d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTexture1D(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_framebuffer_texture_2d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTexture2D(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_framebuffer_texture_3d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLint f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTexture3D(a, b, c, d, e, f);
    rs_check_error();
}

void rs_gl_framebuffer_renderbuffer(GLenum a, GLenum b, GLenum c, GLuint d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferRenderbuffer(a, b, c, d);
    rs_check_error();
}

void rs_gl_get_framebuffer_attachment_parameter_iv(GLenum a, GLenum b, GLenum c, GLint *d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetFramebufferAttachmentParameteriv(a, b, c, d);
    rs_check_error();
}

void rs_gl_generate_mipmap(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenerateMipmap(a);
    rs_check_error();
}

void rs_gl_blit_framebuffer(GLint a, GLint b, GLint c, GLint d, GLint e, GLint f, GLint g, GLint h, GLbitfield i, GLenum j)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBlitFramebuffer(a, b, c, d, e, f, g, h, i, j);
    rs_check_error();
}

void rs_gl_renderbuffer_storage_multisample(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glRenderbufferStorageMultisample(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_framebuffer_texture_layer(GLenum a, GLenum b, GLuint c, GLint d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFramebufferTextureLayer(a, b, c, d, e);
    rs_check_error();
}

/* ARB_map_buffer_range */ 
GLvoid* rs_gl_map_buffer_range(GLenum a, GLintptr b, GLsizeiptr c, GLbitfield d)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLvoid* res = glMapBufferRange(a, b, c, d);
    rs_check_error();
    return res;
}

void rs_gl_flush_mapped_buffer_range(GLenum a, GLintptr b, GLsizeiptr c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glFlushMappedBufferRange(a, b, c);
    rs_check_error();
}

/* ARB_vertex_array_object */ 
void rs_gl_bind_vertex_array(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glBindVertexArray(a);
    rs_check_error();
}

void rs_gl_delete_vertex_arrays(GLsizei a, const GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteVertexArrays(a, b);
    rs_check_error();
}

void rs_gl_gen_vertex_arrays(GLsizei a, GLuint *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGenVertexArrays(a, b);
    rs_check_error();
}

GLboolean rs_gl_is_vertex_array(GLuint a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsVertexArray(a);
    rs_check_error();
    return res;
}


/*  3.1  */ 
/* ARB_copy_buffer */ 
void rs_gl_copy_buffer_sub_data(GLenum a, GLenum b, GLintptr c, GLintptr d, GLsizeiptr e) 
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glCopyBufferSubData(a, b, c, d, e);
    rs_check_error();
}

/* ARB_uniform_buffer_object */ 

/*  3.2  */ 
/* ARB_draw_elements_base_vertex */ 
void rs_gl_draw_elements_base_vertex(GLenum a, GLsizei b, GLenum c, const GLvoid *d, GLint e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawElementsBaseVertex(a, b, c, d, e);
    rs_check_error();
}

void rs_gl_draw_range_elements_base_vertex(GLenum a, GLuint b, GLuint c, GLsizei d, GLenum e, const GLvoid *f, GLint g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawRangeElementsBaseVertex(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_draw_elements_instanced_base_vertex(GLenum a, GLsizei b, GLenum c, const GLvoid *d, GLsizei e, GLint f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDrawElementsInstancedBaseVertex(a, b, c, d, e, f);
    rs_check_error();
}

void rs_gl_multi_draw_elements_base_vertex(GLenum a, const GLsizei *b, GLenum c, const GLvoid* *d, GLsizei e, const GLint *f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glMultiDrawElementsBaseVertex(a, b, c, d, e, f);
    rs_check_error();
}

/* ARB_provoking_vertex */ 
void rs_gl_provoking_vertex(GLenum a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glProvokingVertex(a);
    rs_check_error();
}

/* ARB_sync */ 
GLsync rs_gl_fence_sync(GLenum a, GLbitfield b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLsync res = glFenceSync(a, b);
    rs_check_error();
    return res;
}

GLboolean rs_gl_is_sync(GLsync a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLboolean res = glIsSync(a);
    rs_check_error();
    return res;
}

void rs_gl_delete_sync(GLsync a)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glDeleteSync(a);
    rs_check_error();
}

GLenum rs_gl_client_wait_sync(GLsync a, GLbitfield b, GLuint64 c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    GLenum res = glClientWaitSync(a, b, c);
    rs_check_error();
    return res;
}

void rs_gl_wait_sync(GLsync a, GLbitfield b, GLuint64 c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glWaitSync(a, b, c);
    rs_check_error();
}

void rs_gl_get_integer_64v(GLenum a, GLint64 *b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetInteger64v(a, b);
    rs_check_error();
}

void rs_gl_get_sync_iv(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetSynciv(a, b, c, d, e);
    rs_check_error();
}

/* ARB_texture_multisample */
void rs_gl_tex_image_2d_multisample(GLenum a, GLsizei b, GLint c, GLsizei d, GLsizei e, GLboolean f)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexImage2DMultisample(a, b, c, d, e, f);
    rs_check_error();
}

void rs_gl_tex_image_3d_multisample(GLenum a, GLsizei b, GLint c, GLsizei d, GLsizei e, GLsizei f, GLboolean g)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glTexImage3DMultisample(a, b, c, d, e, f, g);
    rs_check_error();
}

void rs_gl_get_multisample_fv(GLenum a, GLuint b, GLfloat *c)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glGetMultisamplefv(a, b, c);
    rs_check_error();
}

void rs_gl_sample_mask_i(GLuint a, GLbitfield b)
{   RS_LOG_GL_FUNCTION(__FUNCTION__);
    glSampleMaski(a, b);
    rs_check_error();
}

}