rs_gl.h

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.h"
#include "renderstack/rs_platform_opengl.h"


RS_BEGIN_EXTERN_C

void        rs_check_error      (void);
const char *rs_gl_enum_string   (GLenum e);

/*  GL_H  */ 
void rs_gl_array_element(GLint i);
void rs_gl_bind_texture(GLenum target, GLuint texture);
void rs_gl_blend_func(GLenum sfactor, GLenum dfactor);
void rs_gl_clear(GLbitfield mask);
void rs_gl_clear_color(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void rs_gl_clear_depth(GLclampd depth);
void rs_gl_clear_stencil(GLint s);
void rs_gl_color_mask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
void rs_gl_copy_tex_image_1d(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
void rs_gl_copy_tex_image_2d(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
void rs_gl_copy_tex_sub_image_1d(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
void rs_gl_copy_tex_sub_image_2d(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void rs_gl_cull_face(GLenum mode);
void rs_gl_delete_textures(GLsizei n, const GLuint *textures);
void rs_gl_depth_func(GLenum func);
void rs_gl_depth_mask(GLboolean flag);
void rs_gl_depth_range(GLclampd zNear, GLclampd zFar);
void rs_gl_disable(GLenum cap);
void rs_gl_draw_arrays(GLenum mode, GLint first, GLsizei count);
void rs_gl_draw_buffer(GLenum mode);
void rs_gl_draw_elements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
void rs_gl_enable(GLenum cap);
void rs_gl_finish(void);
void rs_gl_flush(void);
void rs_gl_front_face(GLenum mode);
void rs_gl_gen_textures(GLsizei n, GLuint *textures);
void rs_gl_get_boolean_v(GLenum pname, GLboolean *params);
void rs_gl_get_double_v(GLenum pname, GLdouble *params);
GLenum rs_gl_get_error(void);
void rs_gl_get_float_v(GLenum pname, GLfloat *params);
void rs_gl_get_integer_v(GLenum pname, GLint *params);
void rs_gl_get_pointer_v(GLenum pname, GLvoid* *params);
const GLubyte * rs_gl_get_string(GLenum name);
void rs_gl_get_tex_env_fv(GLenum target, GLenum pname, GLfloat *params);
void rs_gl_get_tex_env_iv(GLenum target, GLenum pname, GLint *params);
void rs_gl_get_tex_image(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
void rs_gl_get_tex_level_parameter_fv(GLenum target, GLint level, GLenum pname, GLfloat *params);
void rs_gl_get_tex_level_parameter_iv(GLenum target, GLint level, GLenum pname, GLint *params);
void rs_gl_get_tex_parameter_fv(GLenum target, GLenum pname, GLfloat *params);
void rs_gl_get_tex_parameter_iv(GLenum target, GLenum pname, GLint *params);
void rs_gl_hint(GLenum target, GLenum mode);
GLboolean rs_gl_is_enabled(GLenum cap);
GLboolean rs_gl_is_texture(GLuint texture);
void rs_gl_line_width(GLfloat width);
void rs_gl_logic_op(GLenum opcode);
void rs_gl_pixel_store_f(GLenum pname, GLfloat param);
void rs_gl_pixel_store_i(GLenum pname, GLint param);
void rs_gl_pixel_transfer_f(GLenum pname, GLfloat param);
void rs_gl_pixel_transfer_i(GLenum pname, GLint param);
void rs_gl_point_size(GLfloat size);
void rs_gl_polygon_mode(GLenum face, GLenum mode);
void rs_gl_polygon_offset(GLfloat factor, GLfloat units);
void rs_gl_read_buffer(GLenum mode);
void rs_gl_read_pixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void rs_gl_scissor(GLint x, GLint y, GLsizei width, GLsizei height);
void rs_gl_stencil_func(GLenum func, GLint ref, GLuint mask);
void rs_gl_stencil_mask(GLuint mask);
void rs_gl_stencil_op(GLenum fail, GLenum zfail, GLenum zpass);
void rs_gl_tex_env_f(GLenum target, GLenum pname, GLfloat param);
void rs_gl_tex_env_fv(GLenum target, GLenum pname, const GLfloat *params);
void rs_gl_tex_env_i(GLenum target, GLenum pname, GLint param);
void rs_gl_tex_env_iv(GLenum target, GLenum pname, const GLint *params);
void rs_gl_tex_image_1d(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
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);
void rs_gl_tex_parameter_f(GLenum target, GLenum pname, GLfloat param);
void rs_gl_tex_parameter_fv(GLenum target, GLenum pname, const GLfloat *params);
void rs_gl_tex_parameter_i(GLenum target, GLenum pname, GLint param);
void rs_gl_tex_parameter_iv(GLenum target, GLenum pname, const GLint *params);
void rs_gl_tex_sub_image_1d(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
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);
void rs_gl_viewport(GLint x, GLint y, GLsizei width, GLsizei height);

/*  GL_VERSION_1_2  */ 
void rs_gl_blend_color(GLclampf a, GLclampf b, GLclampf c, GLclampf d);
void rs_gl_blend_equation(GLenum a);
void rs_gl_draw_range_elements(GLenum a, GLuint b, GLuint c, GLsizei d, GLenum e, const GLvoid *f);
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);
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);
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);


/*  GL_VERSION_1_3  */ 
void rs_gl_active_texture(GLenum a);
void rs_gl_sample_coverage(GLclampf a, GLboolean b);
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);
void rs_gl_compressed_tex_image_2d(GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLint f, GLsizei g, const GLvoid *h);
void rs_gl_compressed_tex_image_1d(GLenum a, GLint b, GLenum c, GLsizei d, GLint e, GLsizei f, const GLvoid *g);
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);
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);
void rs_gl_compressed_tex_sub_image_1d(GLenum a, GLint b, GLint c, GLsizei d, GLenum e, GLsizei f, const GLvoid *g);
void rs_gl_get_compressed_tex_image(GLenum a, GLint b, GLvoid *c);


/*  GL_VERSION_1_4  */ 
void rs_gl_blend_func_separate(GLenum a, GLenum b, GLenum c, GLenum d);
void rs_gl_multi_draw_arrays(GLenum a, GLint *b, GLsizei *c, GLsizei d);
void rs_gl_multi_draw_elements(GLenum a, const GLsizei *b, GLenum c, const GLvoid* *d, GLsizei e);
void rs_gl_point_parameter_f(GLenum a, GLfloat b);
void rs_gl_point_parameter_fv(GLenum a, const GLfloat *b);
void rs_gl_point_parameter_i(GLenum a, GLint b);
void rs_gl_point_parameter_iv(GLenum a, const GLint *b);


/*  GL_VERSION_1_5  */ 
void rs_gl_gen_queries(GLsizei a, GLuint *b);
void rs_gl_delete_queries(GLsizei a, const GLuint *b);
GLboolean rs_gl_is_query(GLuint a);
void rs_gl_begin_query(GLenum a, GLuint b);
void rs_gl_end_query(GLenum a);
void rs_gl_get_query_iv(GLenum a, GLenum b, GLint *c);
void rs_gl_get_query_object_iv(GLuint a, GLenum b, GLint *c);
void rs_gl_get_query_object_uiv(GLuint a, GLenum b, GLuint *c);
void rs_gl_bind_buffer(GLenum a, GLuint b);
void rs_gl_delete_buffers(GLsizei a, const GLuint *b);
void rs_gl_gen_buffers(GLsizei a, GLuint *b);
GLboolean rs_gl_is_buffer(GLuint a);
void rs_gl_buffer_data(GLenum a, GLsizeiptr b, const GLvoid *c, GLenum d);
void rs_gl_buffer_sub_data(GLenum a, GLintptr b, GLsizeiptr c, const GLvoid *d);
void rs_gl_get_buffer_sub_data(GLenum a, GLintptr b, GLsizeiptr c, GLvoid *d);
GLvoid* rs_gl_map_buffer(GLenum a, GLenum b);
GLboolean rs_gl_unmap_buffer(GLenum);
void rs_gl_get_buffer_parameter_iv(GLenum a, GLenum b, GLint *c);
void rs_gl_get_buffer_pointer_v(GLenum a, GLenum b, GLvoid* *c);

/*  GL_VERSION_2_0  */ 
void rs_gl_blend_equation_separate(GLenum a, GLenum b);
void rs_gl_draw_buffers(GLsizei a, const GLenum * b);
void rs_gl_stencil_op_separate(GLenum a, GLenum b, GLenum c, GLenum d);
void rs_gl_stencil_func_Separate(GLenum a, GLenum b, GLint c, GLuint d);
void rs_gl_stencil_mask_separate(GLenum a, GLuint b);
void rs_gl_attach_shader(GLuint a, GLuint b);
void rs_gl_bind_attrib_location(GLuint a, GLuint b, const GLchar * c);
void rs_gl_compile_shader(GLuint a);
GLuint rs_gl_create_program(void);
GLuint rs_gl_create_shader(GLenum a);
void rs_gl_delete_program(GLuint a);
void rs_gl_delete_shader(GLuint a);
void rs_gl_detach_shader(GLuint a, GLuint b);
void rs_gl_disable_vertex_attrib_array(GLuint a);
void rs_gl_enable_vertex_attrib_array(GLuint a);
void rs_gl_get_active_attrib(GLuint a, GLuint b, GLsizei c, GLsizei *d, GLint *e, GLenum *f, GLchar *g);
void rs_gl_get_active_uniform(GLuint a, GLuint b , GLsizei c, GLsizei *d, GLint *e, GLenum *f, GLchar *g);
void rs_gl_get_attached_shaders(GLuint a, GLsizei b, GLsizei *c, GLuint *d);
GLint rs_gl_get_attrib_location(GLuint a, const GLchar *b);
void rs_gl_get_program_iv(GLuint a, GLenum b, GLint *c);
void rs_gl_get_program_info_log(GLuint a, GLsizei b, GLsizei *c, GLchar *d);
void rs_gl_get_shader_iv(GLuint a, GLenum b, GLint *c);
void rs_gl_get_shader_info_log(GLuint a, GLsizei b, GLsizei *c, GLchar *d);
void rs_gl_get_shader_source(GLuint a, GLsizei b, GLsizei *c, GLchar *d);
GLint rs_gl_get_uniform_location(GLuint a, const GLchar *b);
void rs_gl_get_uniform_fv(GLuint a, GLint b, GLfloat *c);
void rs_gl_get_uniform_iv(GLuint a, GLint b, GLint *c);
void rs_gl_get_vertex_attrib_dv(GLuint a, GLenum b, GLdouble *c);
void rs_gl_get_vertex_attrib_fv(GLuint a, GLenum b, GLfloat *c);
void rs_gl_get_vertex_attrib_iv(GLuint a, GLenum b, GLint *c);
void rs_gl_get_vertex_attrib_pointer_v(GLuint a, GLenum b, GLvoid* *c);
GLboolean rs_gl_is_program(GLuint a);
GLboolean rs_gl_is_shader(GLuint a);
void rs_gl_link_program(GLuint a);
void rs_gl_shader_source(GLuint a, GLsizei b, const GLchar* *c, const GLint *d);
void rs_gl_use_program(GLuint a);
void rs_gl_uniform_1f(GLint a, GLfloat b);
void rs_gl_uniform_2f(GLint a, GLfloat b, GLfloat c);
void rs_gl_uniform_3f(GLint a, GLfloat b, GLfloat c, GLfloat d);
void rs_gl_uniform_4f(GLint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e);
void rs_gl_uniform_1i(GLint a, GLint b);
void rs_gl_uniform_2i(GLint a, GLint b, GLint c);
void rs_gl_uniform_3i(GLint a, GLint b, GLint c, GLint d);
void rs_gl_uniform_4i(GLint a, GLint b, GLint c, GLint d, GLint e);
void rs_gl_uniform_1fv(GLint a, GLsizei b, const GLfloat *c);
void rs_gl_uniform_2fv(GLint a, GLsizei b, const GLfloat *c);
void rs_gl_uniform_3fv(GLint a, GLsizei b, const GLfloat *c);
void rs_gl_uniform_4fv(GLint a, GLsizei b, const GLfloat *c);
void rs_gl_uniform_1iv(GLint a, GLsizei b, const GLint *c);
void rs_gl_uniform_2iv(GLint a, GLsizei b, const GLint *c);
void rs_gl_uniform_3iv(GLint a, GLsizei b, const GLint *c);
void rs_gl_uniform_4iv(GLint a, GLsizei b, const GLint *c);
void rs_gl_uniform_matrix_2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_3fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_4fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_validate_program(GLuint a);
void rs_gl_vertex_attrib_1d(GLuint a, GLdouble b);
void rs_gl_vertex_attrib_1dv(GLuint a, const GLdouble *b);
void rs_gl_vertex_attrib_1f(GLuint a, GLfloat b);
void rs_gl_vertex_attrib_1fv(GLuint a, const GLfloat *b);
void rs_gl_vertex_attrib_1s(GLuint a, GLshort b);
void rs_gl_vertex_attrib_1sv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_2d(GLuint a, GLdouble b, GLdouble c);
void rs_gl_vertex_attrib_2dv(GLuint a, const GLdouble *b);
void rs_gl_vertex_attrib_2f(GLuint a, GLfloat b, GLfloat c);
void rs_gl_vertex_attrib_2fv(GLuint a, const GLfloat *b);
void rs_gl_vertex_attrib_2s(GLuint a, GLshort b, GLshort c);
void rs_gl_vertex_attrib_2sv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_3d(GLuint a, GLdouble b, GLdouble c, GLdouble d);
void rs_gl_vertex_attrib_3dv(GLuint a, const GLdouble *b);
void rs_gl_vertex_attrib_3f(GLuint a, GLfloat b, GLfloat c, GLfloat d);
void rs_gl_vertex_attrib_3fv(GLuint a, const GLfloat *b);
void rs_gl_vertex_attrib_3s(GLuint a, GLshort b, GLshort c, GLshort d);
void rs_gl_vertex_attrib_3sv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_4Nbv(GLuint a, const GLbyte *b);
void rs_gl_vertex_attrib_4Niv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_4Nsv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_4Nub(GLuint a, GLubyte b, GLubyte c, GLubyte d, GLubyte e);
void rs_gl_vertex_attrib_4Nubv(GLuint a, const GLubyte *b);
void rs_gl_vertex_attrib_4Nuiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_4Nusv(GLuint a, const GLushort *b);
void rs_gl_vertex_attrib_4bv(GLuint a, const GLbyte *b);
void rs_gl_vertex_attrib_4d(GLuint a, GLdouble b, GLdouble c, GLdouble d, GLdouble e);
void rs_gl_vertex_attrib_4dv(GLuint a, const GLdouble *b);
void rs_gl_vertex_attrib_4f(GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e);
void rs_gl_vertex_attrib_4fv(GLuint a, const GLfloat *b);
void rs_gl_vertex_attrib_4iv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_4s(GLuint a, GLshort b, GLshort c, GLshort d, GLshort e);
void rs_gl_vertex_attrib_4sv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_4ubv(GLuint a, const GLubyte *b);
void rs_gl_vertex_attrib_4uiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_4usv(GLuint a, const GLushort *b);
void rs_gl_vertex_attrib_pointer(GLuint a, GLint b, GLenum c, GLboolean d, GLsizei e, const GLvoid *f);

/*  GL_VERSION_2_1  */ 
void rs_gl_uniform_matrix_2x3fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_3x2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_niform_matrix_2x4fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_4x2fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);
void rs_gl_uniform_matrix_fv(GLint a, GLsizei b, GLboolean c, const GLfloat *d);

/*  GL_VERSION_3_0  */ 
void rs_gl_color_mask_i(GLuint a, GLboolean b, GLboolean c, GLboolean d, GLboolean e);
void rs_gl_get_boolean_i_v(GLenum a, GLuint b, GLboolean *c);
void rs_gl_get_integer_i_v(GLenum a, GLuint b, GLint *c);
void rs_gl_enable_i(GLenum a, GLuint b);
void rs_gl_disable_i(GLenum a, GLuint b);
GLboolean rs_gl_is_enabled_i(GLenum a, GLuint b);
void rs_gl_begin_transform_feedback(GLenum a);
void rs_gl_end_transform_feedback(void);
void rs_gl_bind_buffer_range(GLenum a, GLuint b, GLuint c, GLintptr d, GLsizeiptr e);
void rs_gl_bind_buffer_base(GLenum a, GLuint b, GLuint c);
void rs_gl_transform_feedback_varyings(GLuint a, GLsizei b, const GLchar* *c, GLenum d);
void rs_gl_get_transform_feedback_varying(GLuint a, GLuint b, GLsizei c, GLsizei *d, GLsizei *e, GLenum *f, GLchar *g);
void rs_gl_clamp_color(GLenum a, GLenum b);
void rs_gl_begin_conditional_render(GLuint a, GLenum b);
void rs_gl_end_conditional_render(void);
void rs_gl_vertex_attrib_i_pointer(GLuint a, GLint b, GLenum c, GLsizei d, const GLvoid *e);
void rs_gl_get_vertex_attrib_iiv(GLuint a, GLenum b, GLint *c);
void rs_gl_get_vertex_attrib_iuiv(GLuint a, GLenum b, GLuint *c);
void rs_gl_vertex_attrib_i1i(GLuint a, GLint b);
void rs_gl_vertex_attrib_i2i(GLuint a, GLint b, GLint c);
void rs_gl_vertex_attrib_i3i(GLuint a, GLint b, GLint c, GLint d);
void rs_gl_vertex_attrib_i4i(GLuint a, GLint b, GLint c, GLint d, GLint e); 
void rs_gl_vertex_attrib_i1ui(GLuint a, GLuint b);
void rs_gl_vertex_attrib_i2ui(GLuint a, GLuint b, GLuint c);
void rs_gl_vertex_attrib_i3ui(GLuint a, GLuint b, GLuint c, GLuint d);
void rs_gl_vertex_attrib_i4ui(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
void rs_gl_vertex_attrib_i1iv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_i2iv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_i3iv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_i4iv(GLuint a, const GLint *b);
void rs_gl_vertex_attrib_i1uiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_i2uiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_i3uiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_i4uiv(GLuint a, const GLuint *b);
void rs_gl_vertex_attrib_i4bv(GLuint a, const GLbyte *b);
void rs_gl_vertex_attrib_i4sv(GLuint a, const GLshort *b);
void rs_gl_vertex_attrib_i4ubv(GLuint a, const GLubyte *b);
void rs_gl_vertex_attrib_i4usv(GLuint a, const GLushort *b);
void rs_gl_get_uniform_uiv(GLuint a, GLint b, GLuint *c);
void rs_gl_bind_frag_data_location(GLuint a, GLuint b, const GLchar *c);
GLint rs_gl_get_frag_data_location(GLuint a, const GLchar *b);
void rs_gl_uniform_1ui(GLint a, GLuint b);
void rs_gl_uniform_2ui(GLint a, GLuint b, GLuint c);
void rs_gl_uniform_3ui(GLint a, GLuint b, GLuint c, GLuint d);
void rs_gl_uniform_4ui(GLint a, GLuint b, GLuint c, GLuint d, GLuint e);
void rs_gl_uniform_1uiv(GLint a, GLsizei b, const GLuint *c);
void rs_gl_uniform_2uiv(GLint a, GLsizei b, const GLuint *c);
void rs_gl_uniform_3uiv(GLint a, GLsizei b, const GLuint *c);
void rs_gl_uniform_4uiv(GLint a, GLsizei b, const GLuint *c);
void rs_gl_tex_parameter_iiv(GLenum a, GLenum b, const GLint *c);
void rs_gl_tex_parameter_iuiv(GLenum a, GLenum b, const GLuint *c);
void rs_gl_get_tex_parameter_iiv(GLenum a, GLenum b, GLint *c);
void rs_gl_get_tex_parameter_iuiv(GLenum a, GLenum b, GLuint *c);
void rs_gl_clear_buffer_iv(GLenum a, GLint b, const GLint *c);
void rs_gl_clear_buffer_uiv(GLenum a, GLint b, const GLuint *c);
void rs_gl_clear_buffer_fv(GLenum a, GLint b, const GLfloat *c);
void rs_gl_clear_buffer_fi(GLenum a, GLint b, GLfloat c, GLint d);
const GLubyte * rs_gl_get_string_i(GLenum a, GLuint b);

/*  GL_VERSION_3_1  */ 
void rs_gl_draw_arrays_instanced(GLenum a, GLint b, GLsizei c, GLsizei d);
void rs_gl_draw_elements_instanced(GLenum a, GLsizei b, GLenum c, const GLvoid *d, GLsizei e);
void rs_gl_tex_buffer(GLenum a, GLenum b, GLuint c);
void rs_gl_primitive_restart_index(GLuint a);

/*  GL_VERSION_3_2  */ 
void rs_gl_get_integer_64i_v(GLenum a, GLuint b, GLint64 *c);
void rs_gl_get_buffer_parameter_i64v(GLenum a, GLenum b, GLint64 *c);
void rs_gl_program_parameter_i(GLuint a, GLenum b, GLint c);
void rs_gl_framebuffer_texture(GLenum a, GLenum b, GLuint c, GLint d);
void rs_gl_framebuffer_texture_face(GLenum a, GLenum b, GLuint c, GLint d, GLenum e);

/*  3.0  */ 
/*  ARB_framebuffer_object  */ 
GLboolean rs_gl_is_renderbuffer(GLuint a);
void rs_gl_bind_renderbuffer(GLenum a, GLuint b);
void rs_gl_delete_renderbuffers(GLsizei a, const GLuint *b);
void rs_gl_gen_renderbuffers(GLsizei a, GLuint *b);
void rs_gl_renderbuffer_storage(GLenum a, GLenum b, GLsizei c, GLsizei d);
void rs_gl_get_renderbuffer_parameter_iv(GLenum a, GLenum b, GLint *c);
GLboolean rs_gl_is_framebuffer(GLuint a);
void rs_gl_bind_framebuffer(GLenum a, GLuint b);
void rs_gl_delete_framebuffers(GLsizei a, const GLuint *b);
void rs_gl_gen_framebuffers(GLsizei, GLuint *);
GLenum rs_gl_check_framebuffer_status(GLenum a);
void rs_gl_framebuffer_rexture_1d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e);
void rs_gl_framebuffer_texture_2d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e);
void rs_gl_framebuffer_texture_3d(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLint f);
void rs_gl_framebuffer_renderbuffer(GLenum a, GLenum b, GLenum c, GLuint d);
void rs_gl_get_framebuffer_attachment_parameter_iv(GLenum a, GLenum b, GLenum c, GLint *d);
void rs_gl_generate_mipmap(GLenum a);
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);
void rs_gl_renderbuffer_storage_multisample(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
void rs_gl_framebuffer_texture_layer(GLenum a, GLenum b, GLuint c, GLint d, GLint e);

/*  ARB_map_buffer_range  */ 
GLvoid* rs_gl_map_buffer_range(GLenum a, GLintptr b, GLsizeiptr c, GLbitfield d);
void rs_gl_flush_mapped_buffer_range(GLenum a, GLintptr b, GLsizeiptr c);

/*  ARB_vertex_array_object  */ 
void rs_gl_bind_vertex_array(GLuint a);
void rs_gl_delete_vertex_arrays(GLsizei a, const GLuint *b);
void rs_gl_gen_vertex_arrays(GLsizei a, GLuint *b);
GLboolean rs_gl_is_vertex_array(GLuint a);

/*  3.1  */ 
/*  ARB_copy_buffer  */ 
void rs_gl_copy_buffer_sub_data(GLenum a, GLenum b, GLintptr c, GLintptr d, GLsizeiptr e);

/*  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);
void rs_gl_draw_range_elements_base_vertex(GLenum a, GLuint b, GLuint c, GLsizei d, GLenum e, const GLvoid *f, GLint g);
void rs_gl_draw_elements_instanced_base_vertex(GLenum a, GLsizei b, GLenum c, const GLvoid *d, GLsizei e, GLint f);
void rs_gl_multi_draw_elements_base_vertex(GLenum a, const GLsizei *b, GLenum c, const GLvoid* *d, GLsizei e, const GLint *f);

/*  ARB_provoking_vertex  */ 
void rs_gl_provoking_vertex(GLenum a);

/*  ARB_sync  */ 
GLsync rs_gl_fence_sync(GLenum a, GLbitfield b);
GLboolean rs_gl_is_sync(GLsync a);
void rs_gl_delete_sync(GLsync a);
GLenum rs_gl_client_wait_sync(GLsync a, GLbitfield b, GLuint64 c);
void rs_gl_wait_sync(GLsync a, GLbitfield b, GLuint64 c);
void rs_gl_get_integer_64v(GLenum a, GLint64 *b);
void rs_gl_get_sync_iv(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e);

/*  ARB_texture_multisample  */ 
void rs_gl_tex_image_2d_multisample(GLenum a, GLsizei b, GLint c, GLsizei d, GLsizei e, GLboolean f);
void rs_gl_tex_image_3d_multisample(GLenum a, GLsizei b, GLint c, GLsizei d, GLsizei e, GLsizei f, GLboolean g);
void rs_gl_get_multisample_fv(GLenum a, GLuint b, GLfloat *c);
void rs_gl_sample_mask_i(GLuint a, GLbitfield b);

RS_END_EXTERN_C