diff --git a/CMakeLists.txt b/CMakeLists.txt index 978502b0..e08e0ab8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,8 @@ if(AUDIO_BACKEND STREQUAL "") set(AUDIO_BACKEND "openal") elseif(PLATFORM STREQUAL "ps2") set(AUDIO_BACKEND "ps2") + elseif(PLATFORM STREQUAL "libretro") + set(AUDIO_BACKEND "miniaudio") else() set(AUDIO_BACKEND "miniaudio") endif() @@ -99,7 +101,11 @@ if (ENABLE_GLES AND ENABLE_LEGACY_GL) set(ENABLE_LEGACY_GL OFF) endif() -add_executable(butterscotch ${SOURCES} ${PLATFORM_SOURCES} ${AUDIO_SOURCES}) +if(PLATFORM STREQUAL "libretro") + add_library(butterscotch MODULE ${SOURCES} ${PLATFORM_SOURCES} ${AUDIO_SOURCES}) +else() + add_executable(butterscotch ${SOURCES} ${PLATFORM_SOURCES} ${AUDIO_SOURCES}) +endif() target_include_directories(butterscotch PRIVATE ${CMAKE_SOURCE_DIR}/src) if(AUDIO_BACKEND STREQUAL "openal") @@ -618,6 +624,82 @@ elseif(PLATFORM STREQUAL "ps3") # mojoal calls SDL atomics/threads, so SDL2 must link after it (static link order) target_link_libraries(mojoal PUBLIC ${SDL2_LIBRARIES}) target_link_libraries(butterscotch PRIVATE ${SDL2_LIBRARIES} m gcm_sys rsx sysutil io audio rt lv2 io audio bzip2 stb_ds sha1 ps3gl mojoal stb_vorbis) +elseif(PLATFORM STREQUAL "libretro") + # bzip2 needs -fPIC for linking into shared library + set_target_properties(bzip2 PROPERTIES POSITION_INDEPENDENT_CODE ON) + + if(ENABLE_SW_RENDERER) + target_sources(butterscotch PRIVATE + src/sw/sw_renderer.c + src/desktop/stb_impl.c + ) + target_include_directories(butterscotch PRIVATE + ${CMAKE_SOURCE_DIR}/src/sw + ) + else() + target_sources(butterscotch PRIVATE + src/gl/gl_renderer.c + src/gl_common/gl_common.c + src/libretro/libretro-common/glsym/glsym_es3.c + src/libretro/libretro-common/glsm/glsm.c + src/libretro/libretro-common/glsym/rglgen.c + ) + set_source_files_properties( + src/libretro/libretro-common/glsm/glsm.c + PROPERTIES COMPILE_OPTIONS "-w" + ) + target_include_directories(butterscotch PRIVATE + ${CMAKE_SOURCE_DIR}/src/gl + ${CMAKE_SOURCE_DIR}/src/gl_common + ) + target_compile_definitions(butterscotch PRIVATE HAVE_OPENGLES HAVE_OPENGLES3) + add_compile_definitions(ENABLE_GLES) + + find_library(GLES2_LIB GLESv2) + target_link_libraries(butterscotch PRIVATE ${GLES2_LIB}) + + target_compile_definitions(butterscotch PRIVATE GLclampd=GLclampf) + endif() + target_sources(butterscotch PRIVATE + src/image/image_decoder.c + src/desktop/stb_impl.c + ) + + target_include_directories(butterscotch PRIVATE + ${CMAKE_SOURCE_DIR}/src/image + ${CMAKE_SOURCE_DIR}/src/desktop + ${CMAKE_SOURCE_DIR}/src/libretro + ${CMAKE_SOURCE_DIR}/src/libretro/libretro-common/include + vendor/stb/image + vendor/stb/vorbis + ) + + # Rename output to butterscotch_libretro.so + set_target_properties(butterscotch PROPERTIES + PREFIX "" + OUTPUT_NAME "butterscotch_libretro" + ) + + # Version script for symbol visibility + target_link_options(butterscotch PRIVATE + -Wl,--version-script=${CMAKE_SOURCE_DIR}/src/libretro/link.T + -Wl,--no-undefined + ) + + # Libraries + find_library(DL_LIB dl) + find_library(ATOMIC_LIB atomic) + + target_link_libraries(butterscotch PRIVATE bzip2 stb_ds sha1 m ${DL_LIB} ${AUDIO_LIBRARIES}) + if(ATOMIC_LIB) + target_link_libraries(butterscotch PRIVATE ${ATOMIC_LIB}) + endif() + + target_compile_definitions(butterscotch PRIVATE + _GNU_SOURCE + _FILE_OFFSET_BITS=64 + HAVE_LIBRETRO + ) else() message(FATAL_ERROR "Unknown platform! ${PLATFORM}") endif() diff --git a/src/audio/miniaudio/ma_audio_system.c b/src/audio/miniaudio/ma_audio_system.c index d6e9ec87..95078145 100644 --- a/src/audio/miniaudio/ma_audio_system.c +++ b/src/audio/miniaudio/ma_audio_system.c @@ -97,6 +97,11 @@ static void maInit(AudioSystem* audio, DataWin* dataWin, FileSystem* fileSystem) ma->fileSystem = fileSystem; ma_engine_config config = ma_engine_config_init(); +#ifdef HAVE_LIBRETRO + config.noDevice = MA_TRUE; + config.channels = 2; + config.sampleRate = 44100; +#endif ma_result result = ma_engine_init(&config, &ma->engine); if (result != MA_SUCCESS) { fprintf(stderr, "Audio: Failed to initialize miniaudio engine (error %d)\n", result); diff --git a/src/libretro/glad/glad.h b/src/libretro/glad/glad.h new file mode 100644 index 00000000..ec2485b4 --- /dev/null +++ b/src/libretro/glad/glad.h @@ -0,0 +1 @@ +#include diff --git a/src/libretro/libretro-common/glsm/glsm.c b/src/libretro/libretro-common/glsm/glsm.c new file mode 100644 index 00000000..38891450 --- /dev/null +++ b/src/libretro/libretro-common/glsm/glsm.c @@ -0,0 +1,2897 @@ +/* Copyright (C) 2010-2018 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this libretro SDK code part (glsm). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include +#include + +#ifndef GL_DEPTH_CLAMP +#define GL_DEPTH_CLAMP 0x864F +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_SAMPLE_MASK 0x8E51 +#endif + +#if 0 +extern retro_log_printf_t log_cb; +#define GLSM_DEBUG +#endif + +struct gl_cached_state +{ + struct + { + GLuint *ids; + } bind_textures; + + struct + { + bool used[MAX_ATTRIB]; + GLint size[MAX_ATTRIB]; + GLenum type[MAX_ATTRIB]; + GLboolean normalized[MAX_ATTRIB]; + GLsizei stride[MAX_ATTRIB]; + const GLvoid *pointer[MAX_ATTRIB]; + GLuint buffer[MAX_ATTRIB]; + } attrib_pointer; + +#ifndef HAVE_OPENGLES + GLenum colorlogicop; +#endif + + struct + { + bool enabled[MAX_ATTRIB]; + } vertex_attrib_pointer; + + struct + { + GLenum pname; + GLint param; + } pixelstore_i; + + struct + { + GLuint r; + GLuint g; + GLuint b; + GLuint a; + } clear_color; + + struct + { + bool used; + GLint x; + GLint y; + GLsizei w; + GLsizei h; + } scissor; + + struct + { + GLint x; + GLint y; + GLsizei w; + GLsizei h; + } viewport; + + struct + { + bool used; + GLenum sfactor; + GLenum dfactor; + } blendfunc; + + struct + { + bool used; + GLenum srcRGB; + GLenum dstRGB; + GLenum srcAlpha; + GLenum dstAlpha; + } blendfunc_separate; + + struct + { + bool used; + GLboolean red; + GLboolean green; + GLboolean blue; + GLboolean alpha; + } colormask; + + struct + { + bool used; + GLdouble depth; + } cleardepth; + + struct + { + bool used; + GLenum func; + } depthfunc; + + struct + { + bool used; + GLclampd zNear; + GLclampd zFar; + } depthrange; + + struct + { + bool used; + GLfloat factor; + GLfloat units; + } polygonoffset; + + struct + { + bool used; + GLenum func; + GLint ref; + GLuint mask; + } stencilfunc; + + struct + { + bool used; + GLenum sfail; + GLenum dpfail; + GLenum dppass; + } stencilop; + + struct + { + bool used; + GLenum mode; + } frontface; + + struct + { + bool used; + GLenum mode; + } cullface; + + struct + { + bool used; + GLuint mask; + } stencilmask; + + struct + { + bool used; + GLboolean mask; + } depthmask; + + struct + { + GLenum mode; + } readbuffer; + + GLuint vao; + GLuint framebuf; + GLuint array_buffer; + GLuint program; + GLenum active_texture; + int cap_state[SGL_CAP_MAX]; + int cap_translate[SGL_CAP_MAX]; +}; + +static GLuint default_framebuffer; +static GLint glsm_max_textures; +struct retro_hw_render_callback hw_render; +static struct gl_cached_state gl_state; + +/* GL wrapper-side */ + +/* + * + * Core in: + * OpenGL : 1.0 + */ +GLenum rglGetError(void) +{ + return glGetError(); +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : N/A + */ + +void rglProvokingVertex( GLenum provokeMode) +{ +#if defined(HAVE_OPENGL) + glProvokingVertex(provokeMode); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +void rglGetInteger64v( GLenum pname, int64_t *data) +{ +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetInteger64v(pname, (GLint64*)data); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +void rglSamplerParameteri( GLuint sampler, + GLenum pname, + GLint param) +{ +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glSamplerParameteri(sampler, pname, param); +#endif +} + +void rglGenSamplers( GLsizei n, + GLuint *samplers) +{ +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGenSamplers(n, samplers); +#endif +} + +void rglBindSampler( GLuint unit, + GLuint sampler) +{ +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glBindSampler(unit, sampler); +#endif +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglClear(GLbitfield mask) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClear.\n"); +#endif + glClear(mask); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglValidateProgram(GLuint program) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glValidateProgram.\n"); +#endif + glValidateProgram(program); +} + +/* + * + * Core in: + * OpenGL : 1.0 + * OpenGLES : N/A + */ +void rglPolygonMode(GLenum face, GLenum mode) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glPolygonMode.\n"); +#endif +#ifndef HAVE_OPENGLES + glPolygonMode(face, mode); +#endif +} + +void rglTexSubImage2D( + GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const GLvoid * pixels) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexSubImage2D.\n"); +#endif + glTexSubImage2D(target, level, xoffset, yoffset, + width, height, format, type, pixels); +} + +void rglGetBufferSubData( GLenum target, + GLintptr offset, + GLsizeiptr size, + GLvoid * data) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetBufferSubData.\n"); +#endif +#if defined(HAVE_OPENGL) + glGetBufferSubData(target, offset, size, data); +#endif +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglLineWidth(GLfloat width) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glLineWidth.\n"); +#endif + glLineWidth(width); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglBlitFramebuffer( + GLint srcX0, GLint srcY0, + GLint srcX1, GLint srcY1, + GLint dstX0, GLint dstY0, + GLint dstX1, GLint dstY1, + GLbitfield mask, GLenum filter) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlitFramebuffer.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, + mask, filter); +#endif +} + +/* + * + * Core in: + * OpenGLES : 3.0 + */ +void rglReadBuffer(GLenum mode) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glReadBuffer.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glReadBuffer(mode); + gl_state.readbuffer.mode = mode; +#endif +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglClearDepth(GLdouble depth) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClearDepth.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); +#ifdef HAVE_OPENGLES + glClearDepthf(depth); +#else + glClearDepth(depth); +#endif + gl_state.cleardepth.used = true; + gl_state.cleardepth.depth = depth; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglPixelStorei(GLenum pname, GLint param) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glPixelStorei.\n"); +#endif + glPixelStorei(pname, param); + gl_state.pixelstore_i.pname = pname; + gl_state.pixelstore_i.param = param; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglDepthRange(GLclampd zNear, GLclampd zFar) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDepthRange.\n"); +#endif +#ifdef HAVE_OPENGLES + glDepthRangef(zNear, zFar); +#else + glDepthRange(zNear, zFar); +#endif + gl_state.depthrange.used = true; + gl_state.depthrange.zNear = zNear; + gl_state.depthrange.zFar = zFar; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglFrontFace(GLenum mode) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFrontFace.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glFrontFace(mode); + gl_state.frontface.used = true; + gl_state.frontface.mode = mode; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglDepthFunc(GLenum func) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDepthFunc.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + gl_state.depthfunc.used = true; + gl_state.depthfunc.func = func; + glDepthFunc(func); +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglColorMask(GLboolean red, GLboolean green, + GLboolean blue, GLboolean alpha) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glColorMask.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glColorMask(red, green, blue, alpha); + gl_state.colormask.red = red; + gl_state.colormask.green = green; + gl_state.colormask.blue = blue; + gl_state.colormask.alpha = alpha; + gl_state.colormask.used = true; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglCullFace(GLenum mode) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCullFace.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glCullFace(mode); + gl_state.cullface.used = true; + gl_state.cullface.mode = mode; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glStencilOp.\n"); +#endif + glStencilOp(sfail, dpfail, dppass); + gl_state.stencilop.used = true; + gl_state.stencilop.sfail = sfail; + gl_state.stencilop.dpfail = dpfail; + gl_state.stencilop.dppass = dppass; +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglStencilFunc(GLenum func, GLint ref, GLuint mask) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glStencilFunc.\n"); +#endif + glStencilFunc(func, ref, mask); + gl_state.stencilfunc.used = true; + gl_state.stencilfunc.func = func; + gl_state.stencilfunc.ref = ref; + gl_state.stencilfunc.mask = mask; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +GLboolean rglIsEnabled(GLenum cap) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glIsEnabled.\n"); +#endif + return gl_state.cap_state[cap] ? GL_TRUE : GL_FALSE; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglClearColor(GLclampf red, GLclampf green, + GLclampf blue, GLclampf alpha) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClearColor.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glClearColor(red, green, blue, alpha); + gl_state.clear_color.r = red; + gl_state.clear_color.g = green; + gl_state.clear_color.b = blue; + gl_state.clear_color.a = alpha; +} + +/* + * + * Core in: + * OpenGLES : 2.0 (maybe earlier?) + */ +void rglScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glScissor.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glScissor(x, y, width, height); + gl_state.scissor.used = true; + gl_state.scissor.x = x; + gl_state.scissor.y = y; + gl_state.scissor.w = width; + gl_state.scissor.h = height; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glViewport.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glViewport(x, y, width, height); + gl_state.viewport.x = x; + gl_state.viewport.y = y; + gl_state.viewport.w = width; + gl_state.viewport.h = height; +} + +void rglBlendFunc(GLenum sfactor, GLenum dfactor) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlendFunc.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + gl_state.blendfunc.used = true; + gl_state.blendfunc.sfactor = sfactor; + gl_state.blendfunc.dfactor = dfactor; + glBlendFunc(sfactor, dfactor); +} + +/* + * Category: Blending + * + * Core in: + * OpenGL : 1.4 + */ +void rglBlendFuncSeparate(GLenum sfactor, GLenum dfactor) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlendFuncSeparate.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + gl_state.blendfunc_separate.used = true; + gl_state.blendfunc_separate.srcRGB = sfactor; + gl_state.blendfunc_separate.dstRGB = dfactor; + gl_state.blendfunc_separate.srcAlpha = sfactor; + gl_state.blendfunc_separate.dstAlpha = dfactor; + glBlendFunc(sfactor, dfactor); +} + +/* + * Category: Textures + * + * Core in: + * OpenGL : 1.3 + */ +void rglActiveTexture(GLenum texture) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glActiveTexture.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glActiveTexture(texture); + gl_state.active_texture = texture - GL_TEXTURE0; +} + +/* + * + * Core in: + * OpenGL : 1.1 + */ +void rglBindTexture(GLenum target, GLuint texture) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindTexture.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glBindTexture(target, texture); + gl_state.bind_textures.ids[gl_state.active_texture] = texture; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglDisable(GLenum cap) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDisable.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glDisable(gl_state.cap_translate[cap]); + gl_state.cap_state[cap] = 0; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglEnable(GLenum cap) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glEnable.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glEnable(gl_state.cap_translate[cap]); + gl_state.cap_state[cap] = 1; +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUseProgram(GLuint program) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUseProgram.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + gl_state.program = program; + glUseProgram(program); +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglDepthMask(GLboolean flag) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDepthMask.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glDepthMask(flag); + gl_state.depthmask.used = true; + gl_state.depthmask.mask = flag; +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglStencilMask(GLenum mask) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glStencilMask.\n"); +#endif + glStencilMask(mask); + gl_state.stencilmask.used = true; + gl_state.stencilmask.mask = mask; +} + +/* + * + * Core in: + * OpenGL : 1.5 + */ +void rglBufferData(GLenum target, GLsizeiptr size, + const GLvoid *data, GLenum usage) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBufferData.\n"); +#endif + glBufferData(target, size, data, usage); +} + +/* + * + * Core in: + * OpenGL : 1.5 + */ +void rglBufferSubData(GLenum target, GLintptr offset, + GLsizeiptr size, const GLvoid *data) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBufferSubData.\n"); +#endif + glBufferSubData(target, offset, size, data); +} + +/* + * + * Core in: + * OpenGL : 1.5 + */ +void rglBindBuffer(GLenum target, GLuint buffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindBuffer.\n"); +#endif + if (target == GL_ARRAY_BUFFER) + gl_state.array_buffer = buffer; + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glBindBuffer(target, buffer); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglLinkProgram(GLuint program) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glLinkProgram.\n"); +#endif + glLinkProgram(program); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 2.0 + */ +void rglFramebufferTexture2D(GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, GLint level) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFramebufferTexture2D.\n"); +#endif + glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.2 + */ +void rglFramebufferTexture(GLenum target, GLenum attachment, + GLuint texture, GLint level) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFramebufferTexture.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_2) + glFramebufferTexture(target, attachment, texture, level); +#endif +} + +/* + * + * Core in: + * OpenGL : 1.1 + */ +void rglDrawArrays(GLenum mode, GLint first, GLsizei count) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDrawArrays.\n"); +#endif + glDrawArrays(mode, first, count); +} + +/* + * + * Core in: + * OpenGL : 1.1 + */ +void rglDrawElements(GLenum mode, GLsizei count, GLenum type, + const GLvoid * indices) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDrawElements.\n"); +#endif + glDrawElements(mode, count, type, indices); +} + +void rglCompressedTexImage2D(GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLsizei height, + GLint border, GLsizei imageSize, const GLvoid *data) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCompressedTexImage2D.\n"); +#endif + glCompressedTexImage2D(target, level, internalformat, + width, height, border, imageSize, data); +} + +void rglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteFramebuffers.\n"); +#endif + glDeleteFramebuffers(n, framebuffers); +} + +void rglDeleteTextures(GLsizei n, const GLuint *textures) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteTextures.\n"); +#endif + glDeleteTextures(n, textures); +} + +/* + * + * Core in: + * OpenGLES : 2.0 + */ +void rglRenderbufferStorage(GLenum target, GLenum internalFormat, + GLsizei width, GLsizei height) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glRenderbufferStorage.\n"); +#endif + glRenderbufferStorage(target, internalFormat, width, height); +} + +/* + * + * Core in: + * + * OpenGL : 3.0 + * OpenGLES : 2.0 + */ +void rglBindRenderbuffer(GLenum target, GLuint renderbuffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindRenderbuffer.\n"); +#endif + glBindRenderbuffer(target, renderbuffer); +} + +/* + * + * Core in: + * + * OpenGLES : 2.0 + */ +void rglDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteRenderbuffers.\n"); +#endif + glDeleteRenderbuffers(n, renderbuffers); +} + +/* + * + * Core in: + * + * OpenGL : 3.0 + * OpenGLES : 2.0 + */ +void rglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenRenderbuffers.\n"); +#endif + glGenRenderbuffers(n, renderbuffers); +} + +/* + * + * Core in: + * + * OpenGL : 3.0 + * OpenGLES : 2.0 + */ +void rglGenerateMipmap(GLenum target) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenerateMipmap.\n"); +#endif + glGenerateMipmap(target); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + */ +GLenum rglCheckFramebufferStatus(GLenum target) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCheckFramebufferStatus.\n"); +#endif + return glCheckFramebufferStatus(target); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 2.0 + */ +void rglFramebufferRenderbuffer(GLenum target, GLenum attachment, + GLenum renderbuffertarget, GLuint renderbuffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFramebufferRenderbuffer.\n"); +#endif + glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 3.0 + */ +void rglBindFragDataLocation(GLuint program, GLuint colorNumber, + const char * name) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindFragDataLocation.\n"); +#endif +#if !defined(HAVE_OPENGLES2) && !defined(HAVE_OPENGLES3) + glBindFragDataLocation(program, colorNumber, name); +#endif +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglGetProgramiv(GLuint shader, GLenum pname, GLint *params) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetProgramiv.\n"); +#endif + glGetProgramiv(shader, pname, params); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 4.1 + * OpenGLES : 3.0 + */ +void rglProgramParameteri( GLuint program, + GLenum pname, + GLint value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glProgramParameteri.\n"); +#endif +#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES) && (defined(HAVE_OPENGLES3) || defined(HAVE_OPENGLES_3_1)) + glProgramParameteri(program, pname, value); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, + GLsizei *length, GLint *size, GLenum *type, GLchar *name) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetActiveUniform.\n"); +#endif + glGetActiveUniform(program, index, bufsize, length, size, type, name); +} + +void rglGenQueries( GLsizei n, + GLuint * ids) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenQueries.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGenQueries(n, ids); +#endif +} + +void rglGetQueryObjectuiv( GLuint id, + GLenum pname, + GLuint * params) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetQueryObjectuiv.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetQueryObjectuiv(id, pname, params); +#endif +} + +void rglDeleteQueries( GLsizei n, + const GLuint * ids) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteQueries.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glDeleteQueries(n, ids); +#endif +} + +void rglBeginQuery( GLenum target, + GLuint id) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBeginQuery.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glBeginQuery(target, id); +#endif +} + +void rglEndQuery( GLenum target) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glEndQuery.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glEndQuery(target); +#endif +} + +/* + * Category: UBO + * + * Core in: + * + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglGetActiveUniformBlockiv(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLint *params) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetActiveUniformBlockiv.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetActiveUniformBlockiv(program, uniformBlockIndex, + pname, params); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * + * OpenGLES : 3.0 + */ +void rglGetActiveUniformsiv( GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetActiveUniformsiv.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetActiveUniformsiv(program, uniformCount, + uniformIndices, pname, params); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * + * OpenGLES : 3.0 + */ +void rglGetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar **uniformNames, + GLuint *uniformIndices) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetUniformIndices.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetUniformIndices(program, uniformCount, + uniformNames, uniformIndices); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * Category: UBO + * + * Core in: + * + * OpenGLES : 3.0 + */ +void rglBindBufferBase( GLenum target, + GLuint index, + GLuint buffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindBufferBase.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glBindBufferBase(target, index, buffer); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Category: UBO + * + * Core in: + * + * OpenGLES : 3.0 + */ +GLuint rglGetUniformBlockIndex( GLuint program, + const GLchar *uniformBlockName) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetUniformBlockIndex.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + return glGetUniformBlockIndex(program, uniformBlockName); +#else + printf("WARNING! Not implemented.\n"); + return 0; +#endif +} + +/* + * Category: UBO + * + * Core in: + * + * OpenGLES : 3.0 + */ +void rglUniformBlockBinding( GLuint program, + GLuint uniformBlockIndex, + GLuint uniformBlockBinding) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniformBlockBinding.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniformBlockBinding(program, uniformBlockIndex, + uniformBlockBinding); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglUniform1ui(GLint location, GLuint v) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform1ui.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniform1ui(location ,v); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglUniform2ui(GLint location, GLuint v0, GLuint v1) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2ui.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniform2ui(location, v0, v1); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform3ui.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniform3ui(location, v0, v1, v2); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform4ui.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniform4ui(location, v0, v1, v2, v3); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, + const GLfloat *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniformMatrix4fv.\n"); +#endif + glUniformMatrix4fv(location, count, transpose, value); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglDetachShader(GLuint program, GLuint shader) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDetachShader.\n"); +#endif + glDetachShader(program, shader); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglGetShaderiv(GLuint shader, GLenum pname, GLint *params) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetShaderiv.\n"); +#endif + glGetShaderiv(shader, pname, params); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglAttachShader(GLuint program, GLuint shader) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glAttachShader.\n"); +#endif + glAttachShader(program, shader); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +GLint rglGetAttribLocation(GLuint program, const GLchar *name) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetAttribLocation.\n"); +#endif + return glGetAttribLocation(program, name); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglShaderSource(GLuint shader, GLsizei count, + const GLchar **string, const GLint *length) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glShaderSource.\n"); +#endif + return glShaderSource(shader, count, string, length); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglCompileShader(GLuint shader) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCompileShader.\n"); +#endif + glCompileShader(shader); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +GLuint rglCreateProgram(void) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCreateProgram.\n"); +#endif + return glCreateProgram(); +} + +/* + * + * Core in: + * OpenGL : 1.1 + */ +void rglGenTextures(GLsizei n, GLuint *textures) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenTextures.\n"); +#endif + glGenTextures(n, textures); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglGetShaderInfoLog(GLuint shader, GLsizei maxLength, + GLsizei *length, GLchar *infoLog) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetShaderInfoLog.\n"); +#endif + glGetShaderInfoLog(shader, maxLength, length, infoLog); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglGetProgramInfoLog(GLuint shader, GLsizei maxLength, + GLsizei *length, GLchar *infoLog) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetProgramInfoLog.\n"); +#endif + glGetProgramInfoLog(shader, maxLength, length, infoLog); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +GLboolean rglIsProgram(GLuint program) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glIsProgram.\n"); +#endif + return glIsProgram(program); +} + +void rglTexCoord2f(GLfloat s, GLfloat t) +{ +#ifdef HAVE_LEGACY_GL +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexCoord2f.\n"); +#endif + glTexCoord2f(s, t); +#endif +} + +/* + * Category: Generic vertex attributes + * + * Core in: + * OpenGL : 2.0 + * + */ +void rglDisableVertexAttribArray(GLuint index) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDisableVertexAttribArray.\n"); +#endif + gl_state.vertex_attrib_pointer.enabled[index] = 0; + glDisableVertexAttribArray(index); +} + +/* + * Category: Generic vertex attributes + * + * Core in: + * OpenGL : 2.0 + */ +void rglEnableVertexAttribArray(GLuint index) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glEnableVertexAttribArray.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + gl_state.vertex_attrib_pointer.enabled[index] = 1; + glEnableVertexAttribArray(index); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglVertexAttribIPointer( + GLuint index, + GLint size, + GLenum type, + GLsizei stride, + const GLvoid * pointer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glVertexAttribIPointer.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glVertexAttribIPointer(index, size, type, stride, pointer); +#endif +} + +void rglVertexAttribLPointer( + GLuint index, + GLint size, + GLenum type, + GLsizei stride, + const GLvoid * pointer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glVertexAttribLPointer.\n"); +#endif +#if defined(HAVE_OPENGL) + glVertexAttribLPointer(index, size, type, stride, pointer); +#endif +} + +/* + * Category: Generic vertex attributes + * + * Core in: + * OpenGL : 2.0 + */ +void rglVertexAttribPointer(GLuint name, GLint size, + GLenum type, GLboolean normalized, GLsizei stride, + const GLvoid* pointer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glVertexAttribPointer.\n"); +#endif + gl_state.attrib_pointer.used[name] = 1; + gl_state.attrib_pointer.size[name] = size; + gl_state.attrib_pointer.type[name] = type; + gl_state.attrib_pointer.normalized[name] = normalized; + gl_state.attrib_pointer.stride[name] = stride; + gl_state.attrib_pointer.pointer[name] = pointer; + gl_state.attrib_pointer.buffer[name] = gl_state.array_buffer; + glVertexAttribPointer(name, size, type, normalized, stride, pointer); +} + +/* + * Category: Generic vertex attributes + * + * Core in: + * OpenGL : 2.0 + */ +void rglBindAttribLocation(GLuint program, GLuint index, const GLchar *name) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindAttribLocation.\n"); +#endif + glBindAttribLocation(program, index, name); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglVertexAttrib4f(GLuint name, GLfloat x, GLfloat y, + GLfloat z, GLfloat w) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glVertexAttrib4f.\n"); +#endif + glVertexAttrib4f(name, x, y, z, w); +} + +/* + * + * Core in: + * OpenGL : 2.0 + */ +void rglVertexAttrib4fv(GLuint name, GLfloat* v) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glVertexAttrib4fv.\n"); +#endif + glVertexAttrib4fv(name, v); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +GLuint rglCreateShader(GLenum shaderType) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCreateShader.\n"); +#endif + return glCreateShader(shaderType); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglDeleteProgram(GLuint program) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteProgram.\n"); +#endif + glDeleteProgram(program); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglDeleteShader(GLuint shader) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteShader.\n"); +#endif + glDeleteShader(shader); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +GLint rglGetUniformLocation(GLuint program, const GLchar *name) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetUniformLocation.\n"); +#endif + return glGetUniformLocation(program, name); +} + +/* + * Category: VBO and PBO + * + * Core in: + * OpenGL : 1.5 + */ +void rglDeleteBuffers(GLsizei n, const GLuint *buffers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteBuffers.\n"); +#endif + glDeleteBuffers(n, buffers); +} + +/* + * Category: VBO and PBO + * + * Core in: + * OpenGL : 1.5 + */ +void rglGenBuffers(GLsizei n, GLuint *buffers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenBuffers.\n"); +#endif + glGenBuffers(n, buffers); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform1f(GLint location, GLfloat v0) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform1f.\n"); +#endif + glUniform1f(location, v0); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform1fv(GLint location, GLsizei count, const GLfloat *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform1fv.\n"); +#endif + glUniform1fv(location, count, value); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform1iv(GLint location, GLsizei count, const GLint *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform1iv.\n"); +#endif + glUniform1iv(location, count, value); +} + +void rglClearBufferfv( GLenum buffer, + GLint drawBuffer, + const GLfloat * value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClearBufferfv.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3) + glClearBufferfv(buffer, drawBuffer, value); +#endif +} + +void rglTexBuffer(GLenum target, GLenum internalFormat, GLuint buffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexBuffer.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_2) + glTexBuffer(target, internalFormat, buffer); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +const GLubyte* rglGetStringi(GLenum name, GLuint index) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetString.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3) + return glGetStringi(name, index); +#else + return NULL; +#endif +} + +void rglClearBufferfi( GLenum buffer, + GLint drawBuffer, + GLfloat depth, + GLint stencil) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClearBufferfi.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3) + glClearBufferfi(buffer, drawBuffer, depth, stencil); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglRenderbufferStorageMultisample( GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glRenderbufferStorageMultisample.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3) + glRenderbufferStorageMultisample(target, samples, internalformat, width, height); +#endif +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform1i(GLint location, GLint v0) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform1i.\n"); +#endif + glUniform1i(location, v0); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform2f(GLint location, GLfloat v0, GLfloat v1) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2f.\n"); +#endif + glUniform2f(location, v0, v1); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform2i(GLint location, GLint v0, GLint v1) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2i.\n"); +#endif + glUniform2i(location, v0, v1); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform2fv(GLint location, GLsizei count, const GLfloat *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2fv.\n"); +#endif + glUniform2fv(location, count, value); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform3f.\n"); +#endif + glUniform3f(location, v0, v1, v2); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform3fv(GLint location, GLsizei count, const GLfloat *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform3fv.\n"); +#endif + glUniform3fv(location, count, value); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform4i.\n"); +#endif + glUniform4i(location, v0, v1, v2, v3); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform4f.\n"); +#endif + glUniform4f(location, v0, v1, v2, v3); +} + +/* + * Category: Shaders + * + * Core in: + * OpenGL : 2.0 + */ +void rglUniform4fv(GLint location, GLsizei count, const GLfloat *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform4fv.\n"); +#endif + glUniform4fv(location, count, value); +} + +/* + * + * Core in: + * OpenGL : 1.0 + */ +void rglPolygonOffset(GLfloat factor, GLfloat units) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glPolygonOffset.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glPolygonOffset(factor, units); + gl_state.polygonoffset.used = true; + gl_state.polygonoffset.factor = factor; + gl_state.polygonoffset.units = units; +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + */ +void rglGenFramebuffers(GLsizei n, GLuint *ids) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenFramebuffers.\n"); +#endif + glGenFramebuffers(n, ids); +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 3.0 + */ +void rglBindFramebuffer(GLenum target, GLuint framebuffer) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindFramebuffer.\n"); +#endif + glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL); + glBindFramebuffer(target, framebuffer); + gl_state.framebuf = framebuffer; +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void rglDrawBuffers(GLsizei n, const GLenum *bufs) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDrawBuffers.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glDrawBuffers(n, bufs); +#endif +} + +/* + * Category: FBO + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.0 + */ +void *rglMapBufferRange( GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glMapBufferRange.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + return glMapBufferRange(target, offset, length, access); +#else + printf("WARNING! Not implemented.\n"); + return NULL; +#endif +} + +/* + * + * Core in: + * OpenGL : 4.3 + * OpenGLES : 3.1 + */ +void rglTexStorage2DMultisample(GLenum target, GLsizei samples, + GLenum internalformat, GLsizei width, GLsizei height, + GLboolean fixedsamplelocations) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexStorage2DMultisample.\n"); +#endif +#if defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_1) + glTexStorage2DMultisample(target, samples, internalformat, + width, height, fixedsamplelocations); +#endif +} + +/* + * + * Core in: + * OpenGLES : 3.0 + */ +void rglTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, + GLsizei width, GLsizei height) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexStorage2D.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glTexStorage2D(target, levels, internalFormat, width, height); +#endif +} +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.2 + */ +void rglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid *indices, GLint basevertex) +{ +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_2) + glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.2 + * OpenGLES : 3.1 + */ +void rglMemoryBarrier( GLbitfield barriers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glMemoryBarrier.\n"); +#endif +#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3) && defined(HAVE_OPENGLES_3_1) + glMemoryBarrier(barriers); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.2 + * OpenGLES : 3.1 + */ +void rglBindImageTexture( GLuint unit, + GLuint texture, + GLint level, + GLboolean layered, + GLint layer, + GLenum access, + GLenum format) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindImageTexture.\n"); +#endif +#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3) && defined(HAVE_OPENGLES_3_1) + glBindImageTexture(unit, texture, level, layered, layer, access, format); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.1 + * OpenGLES : 3.1 + */ +void rglGetProgramBinary( GLuint program, + GLsizei bufsize, + GLsizei *length, + GLenum *binaryFormat, + void *binary) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGetProgramBinary.\n"); +#endif +#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGetProgramBinary(program, bufsize, length, binaryFormat, binary); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.1 + * OpenGLES : 3.1 + */ +void rglProgramBinary(GLuint program, + GLenum binaryFormat, + const void *binary, + GLsizei length) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glProgramBinary.\n"); +#endif +#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_1) + glProgramBinary(program, binaryFormat, binary, length); +#else + printf("WARNING! Not implemented.\n"); +#endif +} + +void rglTexImage2DMultisample( GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexImage2DMultisample.\n"); +#endif +#ifndef HAVE_OPENGLES + glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); +#endif +} + +void rglTexImage3D( GLenum target, + GLint level, + GLint internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const GLvoid * data) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTexImage3D.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, data); +#endif +} + +/* + * + * Core in: + * OpenGL : 1.5 + */ +void * rglMapBuffer( GLenum target, GLenum access) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glMapBuffer.\n"); +#endif +#if defined(HAVE_OPENGLES) + return glMapBufferOES(target, access); +#else + return glMapBuffer(target, access); +#endif +} + +/* + * + * Core in: + * OpenGL : 1.5 + */ +GLboolean rglUnmapBuffer( GLenum target) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUnmapBuffer.\n"); +#endif +#if defined(HAVE_OPENGLES) + return glUnmapBufferOES(target); +#else + return glUnmapBuffer(target); +#endif +} + +void rglBlendEquation(GLenum mode) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlendEquation.\n"); +#endif + glBlendEquation(mode); +} + +void rglBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlendColor.\n"); +#endif + glBlendColor(red, green, blue, alpha); +} + +/* + * Category: Blending + * + * Core in: + * OpenGL : 2.0 + */ +void rglBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBlendEquationSeparate.\n"); +#endif + glBlendEquationSeparate(modeRGB, modeAlpha); +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 3.2 + */ +void rglCopyImageSubData( 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) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glCopyImageSubData.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_2) + glCopyImageSubData(srcName, + srcTarget, + srcLevel, + srcX, + srcY, + srcZ, + dstName, + dstTarget, + dstLevel, + dstX, + dstY, + dstZ, + srcWidth, + srcHeight, + srcDepth); +#endif +} + +/* + * Category: VAO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglBindVertexArray(GLuint array) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBindVertexArray.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glBindVertexArray(array); +#endif +} + +/* + * Category: VAO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglGenVertexArrays(GLsizei n, GLuint *arrays) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glGenVertexArrays.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glGenVertexArrays(n, arrays); +#endif +} + +/* + * Category: VAO + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglDeleteVertexArrays(GLsizei n, const GLuint *arrays) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteVertexArrays.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glDeleteVertexArrays(n, arrays); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +void *rglFenceSync(GLenum condition, GLbitfield flags) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFenceSync.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + return (GLsync)glFenceSync(condition, flags); +#else + return NULL; +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +void rglDeleteSync(void * sync) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDeleteSync.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glDeleteSync((GLsync)sync); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +void rglWaitSync(void *sync, GLbitfield flags, uint64_t timeout) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glWaitSync.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glWaitSync((GLsync)sync, flags, (GLuint64)timeout); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.4 + * OpenGLES : Not available + */ +void rglBufferStorage(GLenum target, GLsizeiptr size, const GLvoid *data, GLbitfield flags) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glBufferStorage.\n"); +#endif +#if defined(HAVE_OPENGL) + glBufferStorage(target, size, data, flags); +#endif +} + +/* + * + * Core in: + * OpenGL : 2.0 + * OpenGLES : 2.0 + */ + +void rglUniform2iv( GLint location, + GLsizei count, + const GLint *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2iv.\n"); +#endif + glUniform2iv(location, count, value); +} + +/* + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : ?.? + */ + +void rglUniform2uiv( GLint location, + GLsizei count, + const GLuint *value) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glUniform2uiv.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glUniform2uiv(location, count, value); +#endif +} + +/* + * + * Core in: + * OpenGL : 4.3 + * OpenGLES : ?.? + */ +void rglTextureView( GLuint texture, + GLenum target, + GLuint origtexture, + GLenum internalformat, + GLuint minlevel, + GLuint numlevels, + GLuint minlayer, + GLuint numlayers) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glTextureView.\n"); +#endif +#if defined(HAVE_OPENGL) + glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); +#endif +} + +/* + * + * Core in: + * OpenGL : 3.0 + * OpenGLES : 3.0 + */ +void rglFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glFlushMappedBufferRange.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + glFlushMappedBufferRange(target, offset, length); +#endif +} + +#ifndef GL_WAIT_FAILED +#define GL_WAIT_FAILED 0x911D +#endif + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : 3.0 + */ +GLenum rglClientWaitSync(void *sync, GLbitfield flags, uint64_t timeout) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glClientWaitSync.\n"); +#endif +#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) + return glClientWaitSync((GLsync)sync, flags, (GLuint64)timeout); +#else + return GL_WAIT_FAILED; +#endif +} + +/* + * + * Core in: + * OpenGL : 3.2 + * OpenGLES : Not available + */ +void rglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, + GLvoid *indices, GLint basevertex) +{ +#ifdef GLSM_DEBUG + log_cb(RETRO_LOG_INFO, "glDrawElementsBaseVertex.\n"); +#endif +#if defined(HAVE_OPENGL) + glDrawElementsBaseVertex(mode, count, type, indices, basevertex); +#endif +} + +/* GLSM-side */ + +static void glsm_state_setup(void) +{ + unsigned i; + + gl_state.cap_translate[SGL_DEPTH_TEST] = GL_DEPTH_TEST; + gl_state.cap_translate[SGL_BLEND] = GL_BLEND; + gl_state.cap_translate[SGL_POLYGON_OFFSET_FILL] = GL_POLYGON_OFFSET_FILL; + gl_state.cap_translate[SGL_FOG] = GL_FOG; + gl_state.cap_translate[SGL_CULL_FACE] = GL_CULL_FACE; + gl_state.cap_translate[SGL_ALPHA_TEST] = GL_ALPHA_TEST; + gl_state.cap_translate[SGL_SCISSOR_TEST] = GL_SCISSOR_TEST; + gl_state.cap_translate[SGL_STENCIL_TEST] = GL_STENCIL_TEST; + +#ifndef HAVE_OPENGLES + gl_state.cap_translate[SGL_COLOR_LOGIC_OP] = GL_COLOR_LOGIC_OP; + gl_state.cap_translate[SGL_CLIP_DISTANCE0] = GL_CLIP_DISTANCE0; + gl_state.cap_translate[SGL_DEPTH_CLAMP] = GL_DEPTH_CLAMP; +#endif + + for (i = 0; i < MAX_ATTRIB; i++) + { + gl_state.vertex_attrib_pointer.enabled[i] = 0; + gl_state.attrib_pointer.used[i] = 0; + } + + glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &glsm_max_textures); + + gl_state.bind_textures.ids = (GLuint*)calloc(glsm_max_textures, sizeof(GLuint)); + + default_framebuffer = glsm_get_current_framebuffer(); + gl_state.framebuf = default_framebuffer; + gl_state.cullface.mode = GL_BACK; + gl_state.frontface.mode = GL_CCW; + + gl_state.blendfunc_separate.used = false; + gl_state.blendfunc_separate.srcRGB = GL_ONE; + gl_state.blendfunc_separate.dstRGB = GL_ZERO; + gl_state.blendfunc_separate.srcAlpha = GL_ONE; + gl_state.blendfunc_separate.dstAlpha = GL_ZERO; + + gl_state.depthfunc.used = false; + + gl_state.colormask.used = false; + gl_state.colormask.red = GL_TRUE; + gl_state.colormask.green = GL_TRUE; + gl_state.colormask.blue = GL_TRUE; + gl_state.colormask.alpha = GL_TRUE; + + gl_state.polygonoffset.used = false; + + gl_state.depthfunc.func = GL_LESS; + +#ifndef HAVE_OPENGLES + gl_state.colorlogicop = GL_COPY; +#endif + +#ifdef CORE + glGenVertexArrays(1, &gl_state.vao); +#endif +} + +static void glsm_state_bind(void) +{ + unsigned i; +#ifdef CORE + glBindVertexArray(gl_state.vao); +#endif + glBindBuffer(GL_ARRAY_BUFFER, gl_state.array_buffer); + + for (i = 0; i < MAX_ATTRIB; i++) + { + if (gl_state.vertex_attrib_pointer.enabled[i]) + glEnableVertexAttribArray(i); + else + glDisableVertexAttribArray(i); + + if (gl_state.attrib_pointer.used[i] && gl_state.attrib_pointer.buffer[i] == gl_state.array_buffer) + { + glVertexAttribPointer( + i, + gl_state.attrib_pointer.size[i], + gl_state.attrib_pointer.type[i], + gl_state.attrib_pointer.normalized[i], + gl_state.attrib_pointer.stride[i], + gl_state.attrib_pointer.pointer[i]); + } + } + + glBindFramebuffer(RARCH_GL_FRAMEBUFFER, default_framebuffer); + + if (gl_state.blendfunc.used) + glBlendFunc( + gl_state.blendfunc.sfactor, + gl_state.blendfunc.dfactor); + + if (gl_state.blendfunc_separate.used) + glBlendFuncSeparate( + gl_state.blendfunc_separate.srcRGB, + gl_state.blendfunc_separate.dstRGB, + gl_state.blendfunc_separate.srcAlpha, + gl_state.blendfunc_separate.dstAlpha + ); + + glClearColor( + gl_state.clear_color.r, + gl_state.clear_color.g, + gl_state.clear_color.b, + gl_state.clear_color.a); + + if (gl_state.depthfunc.used) + glDepthFunc(gl_state.depthfunc.func); + + if (gl_state.colormask.used) + glColorMask( + gl_state.colormask.red, + gl_state.colormask.green, + gl_state.colormask.blue, + gl_state.colormask.alpha); + + if (gl_state.cullface.used) + glCullFace(gl_state.cullface.mode); + + if (gl_state.depthmask.used) + glDepthMask(gl_state.depthmask.mask); + + if (gl_state.polygonoffset.used) + glPolygonOffset( + gl_state.polygonoffset.factor, + gl_state.polygonoffset.units); + + if (gl_state.scissor.used) + glScissor( + gl_state.scissor.x, + gl_state.scissor.y, + gl_state.scissor.w, + gl_state.scissor.h); + + glUseProgram(gl_state.program); + + glViewport( + gl_state.viewport.x, + gl_state.viewport.y, + gl_state.viewport.w, + gl_state.viewport.h); + + for(i = 0; i < SGL_CAP_MAX; i ++) + { + if (gl_state.cap_state[i]) + glEnable(gl_state.cap_translate[i]); + } + + if (gl_state.frontface.used) + glFrontFace(gl_state.frontface.mode); + + if (gl_state.stencilmask.used) + glStencilMask(gl_state.stencilmask.mask); + + if (gl_state.stencilop.used) + glStencilOp(gl_state.stencilop.sfail, + gl_state.stencilop.dpfail, + gl_state.stencilop.dppass); + + if (gl_state.stencilfunc.used) + glStencilFunc( + gl_state.stencilfunc.func, + gl_state.stencilfunc.ref, + gl_state.stencilfunc.mask); + + for (i = 0; i < glsm_max_textures; i ++) + { + glActiveTexture(GL_TEXTURE0 + i); + glBindTexture(GL_TEXTURE_2D, gl_state.bind_textures.ids[i]); + } + + glActiveTexture(GL_TEXTURE0 + gl_state.active_texture); +} + +static void glsm_state_unbind(void) +{ + unsigned i; +#ifdef CORE + glBindVertexArray(0); +#endif + for (i = 0; i < SGL_CAP_MAX; i ++) + { + if (gl_state.cap_state[i]) + glDisable(gl_state.cap_translate[i]); + } + + glBlendFunc(GL_ONE, GL_ZERO); + + if (gl_state.colormask.used) + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + if (gl_state.blendfunc_separate.used) + glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO); + + if (gl_state.cullface.used) + glCullFace(GL_BACK); + + if (gl_state.depthmask.used) + glDepthMask(GL_TRUE); + + if (gl_state.polygonoffset.used) + glPolygonOffset(0, 0); + + glUseProgram(0); + glClearColor(0,0,0,0.0f); + + if (gl_state.depthrange.used) + rglDepthRange(0, 1); + + glStencilMask(1); + glFrontFace(GL_CCW); + if (gl_state.depthfunc.used) + glDepthFunc(GL_LESS); + + if (gl_state.stencilop.used) + glStencilOp(GL_KEEP,GL_KEEP, GL_KEEP); + + if (gl_state.stencilfunc.used) + glStencilFunc(GL_ALWAYS,0,1); + + /* Clear textures */ + for (i = 0; i < glsm_max_textures; i ++) + { + glActiveTexture(GL_TEXTURE0 + i); + glBindTexture(GL_TEXTURE_2D, 0); + } + glActiveTexture(GL_TEXTURE0); + + for (i = 0; i < MAX_ATTRIB; i ++) + glDisableVertexAttribArray(i); + + glBindFramebuffer(RARCH_GL_FRAMEBUFFER, 0); +} + +static bool glsm_state_ctx_destroy(void *data) +{ + if (gl_state.bind_textures.ids) + free(gl_state.bind_textures.ids); + gl_state.bind_textures.ids = NULL; + + return true; +} + +static bool glsm_state_ctx_init(glsm_ctx_params_t *params) +{ + if (!params || !params->environ_cb) + return false; + +#ifdef HAVE_OPENGLES +#if defined(HAVE_OPENGLES_3_1) + hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES_VERSION; + hw_render.version_major = 3; + hw_render.version_minor = 1; +#elif defined(HAVE_OPENGLES3) + hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES3; +#else + hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES2; +#endif +#else + hw_render.context_type = RETRO_HW_CONTEXT_OPENGL; + if (params->context_type != RETRO_HW_CONTEXT_NONE) + hw_render.context_type = params->context_type; + if (params->major != 0) + hw_render.version_major = params->major; + if (params->minor != 0) + hw_render.version_minor = params->minor; +#endif + + hw_render.context_reset = params->context_reset; + hw_render.context_destroy = params->context_destroy; + hw_render.stencil = params->stencil; + hw_render.depth = true; + hw_render.bottom_left_origin = true; + hw_render.cache_context = false; + + if (!params->environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER, &hw_render)) + return false; + + return true; +} + +GLuint glsm_get_current_framebuffer(void) +{ + return hw_render.get_current_framebuffer(); +} + +bool glsm_ctl(enum glsm_state_ctl state, void *data) +{ + switch (state) + { + case GLSM_CTL_IMM_VBO_DRAW: + return false; + case GLSM_CTL_IMM_VBO_DISABLE: + return false; + case GLSM_CTL_IS_IMM_VBO: + return false; + case GLSM_CTL_SET_IMM_VBO: + break; + case GLSM_CTL_UNSET_IMM_VBO: + break; + case GLSM_CTL_PROC_ADDRESS_GET: + { + glsm_ctx_proc_address_t *proc = (glsm_ctx_proc_address_t*)data; + if (!hw_render.get_proc_address) + return false; + proc->addr = hw_render.get_proc_address; + } + break; + case GLSM_CTL_STATE_CONTEXT_RESET: + rglgen_resolve_symbols(hw_render.get_proc_address); + break; + case GLSM_CTL_STATE_CONTEXT_DESTROY: + glsm_state_ctx_destroy(data); + break; + case GLSM_CTL_STATE_CONTEXT_INIT: + return glsm_state_ctx_init((glsm_ctx_params_t*)data); + case GLSM_CTL_STATE_SETUP: + glsm_state_setup(); + break; + case GLSM_CTL_STATE_UNBIND: + glsm_state_unbind(); + break; + case GLSM_CTL_STATE_BIND: + glsm_state_bind(); + break; + case GLSM_CTL_NONE: + default: + break; + } + + return true; +} diff --git a/src/libretro/libretro-common/glsym/README.md b/src/libretro/libretro-common/glsym/README.md new file mode 100644 index 00000000..5130194f --- /dev/null +++ b/src/libretro/libretro-common/glsym/README.md @@ -0,0 +1,11 @@ +# Autogenerate GL extension loaders + +## OpenGL desktop + +Use Khronos' recent [header](www.opengl.org/registry/api/glext.h). + + ./glgen.py /usr/include/GL/glext.h glsym_gl.h glsym_gl.c + +## OpenGL ES + + ./glgen.py /usr/include/GLES2/gl2ext.h glsym_es2.h glsym_es2.c diff --git a/src/libretro/libretro-common/glsym/glgen.py b/src/libretro/libretro-common/glsym/glgen.py new file mode 100755 index 00000000..8d82357f --- /dev/null +++ b/src/libretro/libretro-common/glsym/glgen.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 + +""" + License statement applies to this file (glgen.py) only. + + Permission is hereby granted, free of charge, + to any person obtaining a copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation the rights to + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +""" + +import sys +import os +import re + +banned_ext = [ 'AMD', 'APPLE', 'NV', 'NVX', 'ATI', '3DLABS', 'SUN', 'SGI', 'SGIX', 'SGIS', 'INTEL', '3DFX', 'IBM', 'MESA', 'GREMEDY', 'OML', 'PGI', 'I3D', 'INGL', 'MTX', 'QCOM', 'IMG', 'ANGLE', 'SUNX', 'INGR' ] + +def noext(sym): + for ext in banned_ext: + if sym.endswith(ext): + return False + return True + +def fix_multiline_functions(lines): + fixed_lines = [] + temp_lines = [] + for line in lines: + if line.count('(') > line.count(')'): + temp_lines.append(line) + else: + if len(temp_lines) > 0: + if line.count(')') > line.count('('): + temp_lines.append(line) + fixed_line = re.sub(' +',' ', ''.join(temp_lines).replace('\n','').replace('\t','')) + fixed_lines.append(fixed_line) + temp_lines = [] + else: + temp_lines.append(line) + else: + fixed_lines.append(line) + return fixed_lines + +def find_gl_symbols(lines): + typedefs = [] + syms = [] + for line in lines: + m = re.search(r'^typedef.+PFN(\S+)PROC.+$', line) + g = re.search(r'^.+(gl\S+)\W*\(.+\).*$', line) + if m and noext(m.group(1)): + typedefs.append(m.group(0).replace('PFN', 'RGLSYM').replace('GLDEBUGPROC', 'RGLGENGLDEBUGPROC')) + if g and noext(g.group(1)): + syms.append(g.group(1)) + return (typedefs, syms) + +def generate_defines(gl_syms): + res = [] + for line in gl_syms: + res.append('#define {} __rglgen_{}'.format(line, line)) + return res + +def generate_declarations(gl_syms): + return ['RGLSYM' + x.upper() + 'PROC ' + '__rglgen_' + x + ';' for x in gl_syms] + +def generate_macros(gl_syms): + return [' SYM(' + x.replace('gl', '') + '),' for x in gl_syms] + +def dump(f, lines): + f.write('\n'.join(lines)) + f.write('\n\n') + +if __name__ == '__main__': + + if len(sys.argv) > 4: + for banned in sys.argv[4:]: + banned_ext.append(banned) + + with open(sys.argv[1], 'r') as f: + lines = fix_multiline_functions(f.readlines()) + typedefs, syms = find_gl_symbols(lines) + + overrides = generate_defines(syms) + declarations = generate_declarations(syms) + externs = ['extern ' + x for x in declarations] + + macros = generate_macros(syms) + + with open(sys.argv[2], 'w') as f: + f.write('#ifndef RGLGEN_DECL_H__\n') + f.write('#define RGLGEN_DECL_H__\n') + + f.write('#ifdef __cplusplus\n') + f.write('extern "C" {\n') + f.write('#endif\n') + + f.write('#ifdef GL_APIENTRY\n') + f.write('typedef void (GL_APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('typedef void (GL_APIENTRY *RGLGENGLDEBUGPROCKHR)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#else\n') + f.write('#ifndef APIENTRY\n') + f.write('#define APIENTRY\n') + f.write('#endif\n') + f.write('#ifndef APIENTRYP\n') + f.write('#define APIENTRYP APIENTRY *\n') + f.write('#endif\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROCARB)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#endif\n') + + f.write('#ifndef GL_OES_EGL_image\n') + f.write('typedef void *GLeglImageOES;\n') + f.write('#endif\n') + + f.write('#if !defined(GL_OES_fixed_point) && !defined(HAVE_OPENGLES2)\n') + f.write('typedef GLint GLfixed;\n') + f.write('#endif\n') + + f.write('#if defined(OSX) && !defined(MAC_OS_X_VERSION_10_7)\n') + f.write('typedef long long int GLint64;\n') + f.write('typedef unsigned long long int GLuint64;\n') + f.write('typedef unsigned long long int GLuint64EXT;\n') + f.write('typedef struct __GLsync *GLsync;\n') + f.write('#endif\n') + + dump(f, typedefs) + dump(f, overrides) + dump(f, externs) + + f.write('struct rglgen_sym_map { const char *sym; void *ptr; };\n') + f.write('extern const struct rglgen_sym_map rglgen_symbol_map[];\n') + + f.write('#ifdef __cplusplus\n') + f.write('}\n') + f.write('#endif\n') + + f.write('#endif\n') + + with open(sys.argv[3], 'w') as f: + f.write('#include "glsym/glsym.h"\n') + f.write('#include \n') + f.write('#define SYM(x) { "gl" #x, &(gl##x) }\n') + f.write('const struct rglgen_sym_map rglgen_symbol_map[] = {\n') + dump(f, macros) + f.write(' { NULL, NULL },\n') + f.write('};\n') + dump(f, declarations) diff --git a/src/libretro/libretro-common/glsym/glsym_es2.c b/src/libretro/libretro-common/glsym/glsym_es2.c new file mode 100644 index 00000000..b9c07064 --- /dev/null +++ b/src/libretro/libretro-common/glsym/glsym_es2.c @@ -0,0 +1,409 @@ +#include "glsym/glsym.h" +#include +#define SYM(x) { "gl" #x, &(gl##x) } +const struct rglgen_sym_map rglgen_symbol_map[] = { + SYM(BlendBarrierKHR), + SYM(DebugMessageControlKHR), + SYM(DebugMessageInsertKHR), + SYM(DebugMessageCallbackKHR), + SYM(GetDebugMessageLogKHR), + SYM(PushDebugGroupKHR), + SYM(PopDebugGroupKHR), + SYM(ObjectLabelKHR), + SYM(GetObjectLabelKHR), + SYM(ObjectPtrLabelKHR), + SYM(GetObjectPtrLabelKHR), + SYM(GetPointervKHR), + SYM(GetGraphicsResetStatusKHR), + SYM(ReadnPixelsKHR), + SYM(GetnUniformfvKHR), + SYM(GetnUniformivKHR), + SYM(GetnUniformuivKHR), + SYM(EGLImageTargetTexture2DOES), + SYM(EGLImageTargetRenderbufferStorageOES), + SYM(CopyImageSubDataOES), + SYM(EnableiOES), + SYM(DisableiOES), + SYM(BlendEquationiOES), + SYM(BlendEquationSeparateiOES), + SYM(BlendFunciOES), + SYM(BlendFuncSeparateiOES), + SYM(ColorMaskiOES), + SYM(IsEnablediOES), + SYM(DrawElementsBaseVertexOES), + SYM(DrawRangeElementsBaseVertexOES), + SYM(DrawElementsInstancedBaseVertexOES), + SYM(MultiDrawElementsBaseVertexOES), + SYM(FramebufferTextureOES), + SYM(GetProgramBinaryOES), + SYM(ProgramBinaryOES), + SYM(MapBufferOES), + SYM(UnmapBufferOES), + SYM(GetBufferPointervOES), + SYM(PrimitiveBoundingBoxOES), + SYM(MinSampleShadingOES), + SYM(PatchParameteriOES), + SYM(TexImage3DOES), + SYM(TexSubImage3DOES), + SYM(CopyTexSubImage3DOES), + SYM(CompressedTexImage3DOES), + SYM(CompressedTexSubImage3DOES), + SYM(FramebufferTexture3DOES), + SYM(TexParameterIivOES), + SYM(TexParameterIuivOES), + SYM(GetTexParameterIivOES), + SYM(GetTexParameterIuivOES), + SYM(SamplerParameterIivOES), + SYM(SamplerParameterIuivOES), + SYM(GetSamplerParameterIivOES), + SYM(GetSamplerParameterIuivOES), + SYM(TexBufferOES), + SYM(TexBufferRangeOES), + SYM(TexStorage3DMultisampleOES), + SYM(TextureViewOES), + SYM(BindVertexArrayOES), + SYM(DeleteVertexArraysOES), + SYM(GenVertexArraysOES), + SYM(IsVertexArrayOES), + SYM(ViewportArrayvOES), + SYM(ViewportIndexedfOES), + SYM(ViewportIndexedfvOES), + SYM(ScissorArrayvOES), + SYM(ScissorIndexedOES), + SYM(ScissorIndexedvOES), + SYM(DepthRangeArrayfvOES), + SYM(DepthRangeIndexedfOES), + SYM(GetFloati_vOES), + SYM(DrawArraysInstancedBaseInstanceEXT), + SYM(DrawElementsInstancedBaseInstanceEXT), + SYM(DrawElementsInstancedBaseVertexBaseInstanceEXT), + SYM(BindFragDataLocationIndexedEXT), + SYM(BindFragDataLocationEXT), + SYM(GetProgramResourceLocationIndexEXT), + SYM(GetFragDataIndexEXT), + SYM(BufferStorageEXT), + SYM(ClearTexImageEXT), + SYM(ClearTexSubImageEXT), + SYM(CopyImageSubDataEXT), + SYM(LabelObjectEXT), + SYM(GetObjectLabelEXT), + SYM(InsertEventMarkerEXT), + SYM(PushGroupMarkerEXT), + SYM(PopGroupMarkerEXT), + SYM(DiscardFramebufferEXT), + SYM(GenQueriesEXT), + SYM(DeleteQueriesEXT), + SYM(IsQueryEXT), + SYM(BeginQueryEXT), + SYM(EndQueryEXT), + SYM(QueryCounterEXT), + SYM(GetQueryivEXT), + SYM(GetQueryObjectivEXT), + SYM(GetQueryObjectuivEXT), + SYM(DrawBuffersEXT), + SYM(EnableiEXT), + SYM(DisableiEXT), + SYM(BlendEquationiEXT), + SYM(BlendEquationSeparateiEXT), + SYM(BlendFunciEXT), + SYM(BlendFuncSeparateiEXT), + SYM(ColorMaskiEXT), + SYM(IsEnablediEXT), + SYM(DrawElementsBaseVertexEXT), + SYM(DrawRangeElementsBaseVertexEXT), + SYM(DrawElementsInstancedBaseVertexEXT), + SYM(MultiDrawElementsBaseVertexEXT), + SYM(DrawArraysInstancedEXT), + SYM(DrawElementsInstancedEXT), + SYM(FramebufferTextureEXT), + SYM(VertexAttribDivisorEXT), + SYM(MapBufferRangeEXT), + SYM(FlushMappedBufferRangeEXT), + SYM(MultiDrawArraysEXT), + SYM(MultiDrawElementsEXT), + SYM(MultiDrawArraysIndirectEXT), + SYM(MultiDrawElementsIndirectEXT), + SYM(RenderbufferStorageMultisampleEXT), + SYM(FramebufferTexture2DMultisampleEXT), + SYM(ReadBufferIndexedEXT), + SYM(DrawBuffersIndexedEXT), + SYM(GetIntegeri_vEXT), + SYM(PolygonOffsetClampEXT), + SYM(PrimitiveBoundingBoxEXT), + SYM(RasterSamplesEXT), + SYM(GetGraphicsResetStatusEXT), + SYM(ReadnPixelsEXT), + SYM(GetnUniformfvEXT), + SYM(GetnUniformivEXT), + SYM(ActiveShaderProgramEXT), + SYM(BindProgramPipelineEXT), + SYM(CreateShaderProgramvEXT), + SYM(DeleteProgramPipelinesEXT), + SYM(GenProgramPipelinesEXT), + SYM(GetProgramPipelineInfoLogEXT), + SYM(GetProgramPipelineivEXT), + SYM(IsProgramPipelineEXT), + SYM(ProgramParameteriEXT), + SYM(ProgramUniform1fEXT), + SYM(ProgramUniform1fvEXT), + SYM(ProgramUniform1iEXT), + SYM(ProgramUniform1ivEXT), + SYM(ProgramUniform2fEXT), + SYM(ProgramUniform2fvEXT), + SYM(ProgramUniform2iEXT), + SYM(ProgramUniform2ivEXT), + SYM(ProgramUniform3fEXT), + SYM(ProgramUniform3fvEXT), + SYM(ProgramUniform3iEXT), + SYM(ProgramUniform3ivEXT), + SYM(ProgramUniform4fEXT), + SYM(ProgramUniform4fvEXT), + SYM(ProgramUniform4iEXT), + SYM(ProgramUniform4ivEXT), + SYM(ProgramUniformMatrix2fvEXT), + SYM(ProgramUniformMatrix3fvEXT), + SYM(ProgramUniformMatrix4fvEXT), + SYM(UseProgramStagesEXT), + SYM(ValidateProgramPipelineEXT), + SYM(ProgramUniform1uiEXT), + SYM(ProgramUniform2uiEXT), + SYM(ProgramUniform3uiEXT), + SYM(ProgramUniform4uiEXT), + SYM(ProgramUniform1uivEXT), + SYM(ProgramUniform2uivEXT), + SYM(ProgramUniform3uivEXT), + SYM(ProgramUniform4uivEXT), + SYM(ProgramUniformMatrix2x3fvEXT), + SYM(ProgramUniformMatrix3x2fvEXT), + SYM(ProgramUniformMatrix2x4fvEXT), + SYM(ProgramUniformMatrix4x2fvEXT), + SYM(ProgramUniformMatrix3x4fvEXT), + SYM(ProgramUniformMatrix4x3fvEXT), + SYM(FramebufferPixelLocalStorageSizeEXT), + SYM(GetFramebufferPixelLocalStorageSizeEXT), + SYM(ClearPixelLocalStorageuiEXT), + SYM(TexPageCommitmentEXT), + SYM(PatchParameteriEXT), + SYM(TexParameterIivEXT), + SYM(TexParameterIuivEXT), + SYM(GetTexParameterIivEXT), + SYM(GetTexParameterIuivEXT), + SYM(SamplerParameterIivEXT), + SYM(SamplerParameterIuivEXT), + SYM(GetSamplerParameterIivEXT), + SYM(GetSamplerParameterIuivEXT), + SYM(TexBufferEXT), + SYM(TexBufferRangeEXT), + SYM(TexStorage1DEXT), + SYM(TexStorage2DEXT), + SYM(TexStorage3DEXT), + SYM(TextureStorage1DEXT), + SYM(TextureStorage2DEXT), + SYM(TextureStorage3DEXT), + SYM(TextureViewEXT), + SYM(FramebufferTextureMultiviewOVR), + SYM(FramebufferTextureMultisampleMultiviewOVR), + + { NULL, NULL }, +}; +RGLSYMGLBLENDBARRIERKHRPROC __rglgen_glBlendBarrierKHR; +RGLSYMGLDEBUGMESSAGECONTROLKHRPROC __rglgen_glDebugMessageControlKHR; +RGLSYMGLDEBUGMESSAGEINSERTKHRPROC __rglgen_glDebugMessageInsertKHR; +RGLSYMGLDEBUGMESSAGECALLBACKKHRPROC __rglgen_glDebugMessageCallbackKHR; +RGLSYMGLGETDEBUGMESSAGELOGKHRPROC __rglgen_glGetDebugMessageLogKHR; +RGLSYMGLPUSHDEBUGGROUPKHRPROC __rglgen_glPushDebugGroupKHR; +RGLSYMGLPOPDEBUGGROUPKHRPROC __rglgen_glPopDebugGroupKHR; +RGLSYMGLOBJECTLABELKHRPROC __rglgen_glObjectLabelKHR; +RGLSYMGLGETOBJECTLABELKHRPROC __rglgen_glGetObjectLabelKHR; +RGLSYMGLOBJECTPTRLABELKHRPROC __rglgen_glObjectPtrLabelKHR; +RGLSYMGLGETOBJECTPTRLABELKHRPROC __rglgen_glGetObjectPtrLabelKHR; +RGLSYMGLGETPOINTERVKHRPROC __rglgen_glGetPointervKHR; +RGLSYMGLGETGRAPHICSRESETSTATUSKHRPROC __rglgen_glGetGraphicsResetStatusKHR; +RGLSYMGLREADNPIXELSKHRPROC __rglgen_glReadnPixelsKHR; +RGLSYMGLGETNUNIFORMFVKHRPROC __rglgen_glGetnUniformfvKHR; +RGLSYMGLGETNUNIFORMIVKHRPROC __rglgen_glGetnUniformivKHR; +RGLSYMGLGETNUNIFORMUIVKHRPROC __rglgen_glGetnUniformuivKHR; +RGLSYMGLEGLIMAGETARGETTEXTURE2DOESPROC __rglgen_glEGLImageTargetTexture2DOES; +RGLSYMGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC __rglgen_glEGLImageTargetRenderbufferStorageOES; +RGLSYMGLCOPYIMAGESUBDATAOESPROC __rglgen_glCopyImageSubDataOES; +RGLSYMGLENABLEIOESPROC __rglgen_glEnableiOES; +RGLSYMGLDISABLEIOESPROC __rglgen_glDisableiOES; +RGLSYMGLBLENDEQUATIONIOESPROC __rglgen_glBlendEquationiOES; +RGLSYMGLBLENDEQUATIONSEPARATEIOESPROC __rglgen_glBlendEquationSeparateiOES; +RGLSYMGLBLENDFUNCIOESPROC __rglgen_glBlendFunciOES; +RGLSYMGLBLENDFUNCSEPARATEIOESPROC __rglgen_glBlendFuncSeparateiOES; +RGLSYMGLCOLORMASKIOESPROC __rglgen_glColorMaskiOES; +RGLSYMGLISENABLEDIOESPROC __rglgen_glIsEnablediOES; +RGLSYMGLDRAWELEMENTSBASEVERTEXOESPROC __rglgen_glDrawElementsBaseVertexOES; +RGLSYMGLDRAWRANGEELEMENTSBASEVERTEXOESPROC __rglgen_glDrawRangeElementsBaseVertexOES; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXOESPROC __rglgen_glDrawElementsInstancedBaseVertexOES; +RGLSYMGLMULTIDRAWELEMENTSBASEVERTEXOESPROC __rglgen_glMultiDrawElementsBaseVertexOES; +RGLSYMGLFRAMEBUFFERTEXTUREOESPROC __rglgen_glFramebufferTextureOES; +RGLSYMGLGETPROGRAMBINARYOESPROC __rglgen_glGetProgramBinaryOES; +RGLSYMGLPROGRAMBINARYOESPROC __rglgen_glProgramBinaryOES; +RGLSYMGLMAPBUFFEROESPROC __rglgen_glMapBufferOES; +RGLSYMGLUNMAPBUFFEROESPROC __rglgen_glUnmapBufferOES; +RGLSYMGLGETBUFFERPOINTERVOESPROC __rglgen_glGetBufferPointervOES; +RGLSYMGLPRIMITIVEBOUNDINGBOXOESPROC __rglgen_glPrimitiveBoundingBoxOES; +RGLSYMGLMINSAMPLESHADINGOESPROC __rglgen_glMinSampleShadingOES; +RGLSYMGLPATCHPARAMETERIOESPROC __rglgen_glPatchParameteriOES; +RGLSYMGLTEXIMAGE3DOESPROC __rglgen_glTexImage3DOES; +RGLSYMGLTEXSUBIMAGE3DOESPROC __rglgen_glTexSubImage3DOES; +RGLSYMGLCOPYTEXSUBIMAGE3DOESPROC __rglgen_glCopyTexSubImage3DOES; +RGLSYMGLCOMPRESSEDTEXIMAGE3DOESPROC __rglgen_glCompressedTexImage3DOES; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE3DOESPROC __rglgen_glCompressedTexSubImage3DOES; +RGLSYMGLFRAMEBUFFERTEXTURE3DOESPROC __rglgen_glFramebufferTexture3DOES; +RGLSYMGLTEXPARAMETERIIVOESPROC __rglgen_glTexParameterIivOES; +RGLSYMGLTEXPARAMETERIUIVOESPROC __rglgen_glTexParameterIuivOES; +RGLSYMGLGETTEXPARAMETERIIVOESPROC __rglgen_glGetTexParameterIivOES; +RGLSYMGLGETTEXPARAMETERIUIVOESPROC __rglgen_glGetTexParameterIuivOES; +RGLSYMGLSAMPLERPARAMETERIIVOESPROC __rglgen_glSamplerParameterIivOES; +RGLSYMGLSAMPLERPARAMETERIUIVOESPROC __rglgen_glSamplerParameterIuivOES; +RGLSYMGLGETSAMPLERPARAMETERIIVOESPROC __rglgen_glGetSamplerParameterIivOES; +RGLSYMGLGETSAMPLERPARAMETERIUIVOESPROC __rglgen_glGetSamplerParameterIuivOES; +RGLSYMGLTEXBUFFEROESPROC __rglgen_glTexBufferOES; +RGLSYMGLTEXBUFFERRANGEOESPROC __rglgen_glTexBufferRangeOES; +RGLSYMGLTEXSTORAGE3DMULTISAMPLEOESPROC __rglgen_glTexStorage3DMultisampleOES; +RGLSYMGLTEXTUREVIEWOESPROC __rglgen_glTextureViewOES; +RGLSYMGLBINDVERTEXARRAYOESPROC __rglgen_glBindVertexArrayOES; +RGLSYMGLDELETEVERTEXARRAYSOESPROC __rglgen_glDeleteVertexArraysOES; +RGLSYMGLGENVERTEXARRAYSOESPROC __rglgen_glGenVertexArraysOES; +RGLSYMGLISVERTEXARRAYOESPROC __rglgen_glIsVertexArrayOES; +RGLSYMGLVIEWPORTARRAYVOESPROC __rglgen_glViewportArrayvOES; +RGLSYMGLVIEWPORTINDEXEDFOESPROC __rglgen_glViewportIndexedfOES; +RGLSYMGLVIEWPORTINDEXEDFVOESPROC __rglgen_glViewportIndexedfvOES; +RGLSYMGLSCISSORARRAYVOESPROC __rglgen_glScissorArrayvOES; +RGLSYMGLSCISSORINDEXEDOESPROC __rglgen_glScissorIndexedOES; +RGLSYMGLSCISSORINDEXEDVOESPROC __rglgen_glScissorIndexedvOES; +RGLSYMGLDEPTHRANGEARRAYFVOESPROC __rglgen_glDepthRangeArrayfvOES; +RGLSYMGLDEPTHRANGEINDEXEDFOESPROC __rglgen_glDepthRangeIndexedfOES; +RGLSYMGLGETFLOATI_VOESPROC __rglgen_glGetFloati_vOES; +RGLSYMGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __rglgen_glDrawArraysInstancedBaseInstanceEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __rglgen_glDrawElementsInstancedBaseInstanceEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __rglgen_glDrawElementsInstancedBaseVertexBaseInstanceEXT; +RGLSYMGLBINDFRAGDATALOCATIONINDEXEDEXTPROC __rglgen_glBindFragDataLocationIndexedEXT; +RGLSYMGLBINDFRAGDATALOCATIONEXTPROC __rglgen_glBindFragDataLocationEXT; +RGLSYMGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC __rglgen_glGetProgramResourceLocationIndexEXT; +RGLSYMGLGETFRAGDATAINDEXEXTPROC __rglgen_glGetFragDataIndexEXT; +RGLSYMGLBUFFERSTORAGEEXTPROC __rglgen_glBufferStorageEXT; +RGLSYMGLCLEARTEXIMAGEEXTPROC __rglgen_glClearTexImageEXT; +RGLSYMGLCLEARTEXSUBIMAGEEXTPROC __rglgen_glClearTexSubImageEXT; +RGLSYMGLCOPYIMAGESUBDATAEXTPROC __rglgen_glCopyImageSubDataEXT; +RGLSYMGLLABELOBJECTEXTPROC __rglgen_glLabelObjectEXT; +RGLSYMGLGETOBJECTLABELEXTPROC __rglgen_glGetObjectLabelEXT; +RGLSYMGLINSERTEVENTMARKEREXTPROC __rglgen_glInsertEventMarkerEXT; +RGLSYMGLPUSHGROUPMARKEREXTPROC __rglgen_glPushGroupMarkerEXT; +RGLSYMGLPOPGROUPMARKEREXTPROC __rglgen_glPopGroupMarkerEXT; +RGLSYMGLDISCARDFRAMEBUFFEREXTPROC __rglgen_glDiscardFramebufferEXT; +RGLSYMGLGENQUERIESEXTPROC __rglgen_glGenQueriesEXT; +RGLSYMGLDELETEQUERIESEXTPROC __rglgen_glDeleteQueriesEXT; +RGLSYMGLISQUERYEXTPROC __rglgen_glIsQueryEXT; +RGLSYMGLBEGINQUERYEXTPROC __rglgen_glBeginQueryEXT; +RGLSYMGLENDQUERYEXTPROC __rglgen_glEndQueryEXT; +RGLSYMGLQUERYCOUNTEREXTPROC __rglgen_glQueryCounterEXT; +RGLSYMGLGETQUERYIVEXTPROC __rglgen_glGetQueryivEXT; +RGLSYMGLGETQUERYOBJECTIVEXTPROC __rglgen_glGetQueryObjectivEXT; +RGLSYMGLGETQUERYOBJECTUIVEXTPROC __rglgen_glGetQueryObjectuivEXT; +RGLSYMGLDRAWBUFFERSEXTPROC __rglgen_glDrawBuffersEXT; +RGLSYMGLENABLEIEXTPROC __rglgen_glEnableiEXT; +RGLSYMGLDISABLEIEXTPROC __rglgen_glDisableiEXT; +RGLSYMGLBLENDEQUATIONIEXTPROC __rglgen_glBlendEquationiEXT; +RGLSYMGLBLENDEQUATIONSEPARATEIEXTPROC __rglgen_glBlendEquationSeparateiEXT; +RGLSYMGLBLENDFUNCIEXTPROC __rglgen_glBlendFunciEXT; +RGLSYMGLBLENDFUNCSEPARATEIEXTPROC __rglgen_glBlendFuncSeparateiEXT; +RGLSYMGLCOLORMASKIEXTPROC __rglgen_glColorMaskiEXT; +RGLSYMGLISENABLEDIEXTPROC __rglgen_glIsEnablediEXT; +RGLSYMGLDRAWELEMENTSBASEVERTEXEXTPROC __rglgen_glDrawElementsBaseVertexEXT; +RGLSYMGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC __rglgen_glDrawRangeElementsBaseVertexEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC __rglgen_glDrawElementsInstancedBaseVertexEXT; +RGLSYMGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC __rglgen_glMultiDrawElementsBaseVertexEXT; +RGLSYMGLDRAWARRAYSINSTANCEDEXTPROC __rglgen_glDrawArraysInstancedEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDEXTPROC __rglgen_glDrawElementsInstancedEXT; +RGLSYMGLFRAMEBUFFERTEXTUREEXTPROC __rglgen_glFramebufferTextureEXT; +RGLSYMGLVERTEXATTRIBDIVISOREXTPROC __rglgen_glVertexAttribDivisorEXT; +RGLSYMGLMAPBUFFERRANGEEXTPROC __rglgen_glMapBufferRangeEXT; +RGLSYMGLFLUSHMAPPEDBUFFERRANGEEXTPROC __rglgen_glFlushMappedBufferRangeEXT; +RGLSYMGLMULTIDRAWARRAYSEXTPROC __rglgen_glMultiDrawArraysEXT; +RGLSYMGLMULTIDRAWELEMENTSEXTPROC __rglgen_glMultiDrawElementsEXT; +RGLSYMGLMULTIDRAWARRAYSINDIRECTEXTPROC __rglgen_glMultiDrawArraysIndirectEXT; +RGLSYMGLMULTIDRAWELEMENTSINDIRECTEXTPROC __rglgen_glMultiDrawElementsIndirectEXT; +RGLSYMGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __rglgen_glRenderbufferStorageMultisampleEXT; +RGLSYMGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC __rglgen_glFramebufferTexture2DMultisampleEXT; +RGLSYMGLREADBUFFERINDEXEDEXTPROC __rglgen_glReadBufferIndexedEXT; +RGLSYMGLDRAWBUFFERSINDEXEDEXTPROC __rglgen_glDrawBuffersIndexedEXT; +RGLSYMGLGETINTEGERI_VEXTPROC __rglgen_glGetIntegeri_vEXT; +RGLSYMGLPOLYGONOFFSETCLAMPEXTPROC __rglgen_glPolygonOffsetClampEXT; +RGLSYMGLPRIMITIVEBOUNDINGBOXEXTPROC __rglgen_glPrimitiveBoundingBoxEXT; +RGLSYMGLRASTERSAMPLESEXTPROC __rglgen_glRasterSamplesEXT; +RGLSYMGLGETGRAPHICSRESETSTATUSEXTPROC __rglgen_glGetGraphicsResetStatusEXT; +RGLSYMGLREADNPIXELSEXTPROC __rglgen_glReadnPixelsEXT; +RGLSYMGLGETNUNIFORMFVEXTPROC __rglgen_glGetnUniformfvEXT; +RGLSYMGLGETNUNIFORMIVEXTPROC __rglgen_glGetnUniformivEXT; +RGLSYMGLACTIVESHADERPROGRAMEXTPROC __rglgen_glActiveShaderProgramEXT; +RGLSYMGLBINDPROGRAMPIPELINEEXTPROC __rglgen_glBindProgramPipelineEXT; +RGLSYMGLCREATESHADERPROGRAMVEXTPROC __rglgen_glCreateShaderProgramvEXT; +RGLSYMGLDELETEPROGRAMPIPELINESEXTPROC __rglgen_glDeleteProgramPipelinesEXT; +RGLSYMGLGENPROGRAMPIPELINESEXTPROC __rglgen_glGenProgramPipelinesEXT; +RGLSYMGLGETPROGRAMPIPELINEINFOLOGEXTPROC __rglgen_glGetProgramPipelineInfoLogEXT; +RGLSYMGLGETPROGRAMPIPELINEIVEXTPROC __rglgen_glGetProgramPipelineivEXT; +RGLSYMGLISPROGRAMPIPELINEEXTPROC __rglgen_glIsProgramPipelineEXT; +RGLSYMGLPROGRAMPARAMETERIEXTPROC __rglgen_glProgramParameteriEXT; +RGLSYMGLPROGRAMUNIFORM1FEXTPROC __rglgen_glProgramUniform1fEXT; +RGLSYMGLPROGRAMUNIFORM1FVEXTPROC __rglgen_glProgramUniform1fvEXT; +RGLSYMGLPROGRAMUNIFORM1IEXTPROC __rglgen_glProgramUniform1iEXT; +RGLSYMGLPROGRAMUNIFORM1IVEXTPROC __rglgen_glProgramUniform1ivEXT; +RGLSYMGLPROGRAMUNIFORM2FEXTPROC __rglgen_glProgramUniform2fEXT; +RGLSYMGLPROGRAMUNIFORM2FVEXTPROC __rglgen_glProgramUniform2fvEXT; +RGLSYMGLPROGRAMUNIFORM2IEXTPROC __rglgen_glProgramUniform2iEXT; +RGLSYMGLPROGRAMUNIFORM2IVEXTPROC __rglgen_glProgramUniform2ivEXT; +RGLSYMGLPROGRAMUNIFORM3FEXTPROC __rglgen_glProgramUniform3fEXT; +RGLSYMGLPROGRAMUNIFORM3FVEXTPROC __rglgen_glProgramUniform3fvEXT; +RGLSYMGLPROGRAMUNIFORM3IEXTPROC __rglgen_glProgramUniform3iEXT; +RGLSYMGLPROGRAMUNIFORM3IVEXTPROC __rglgen_glProgramUniform3ivEXT; +RGLSYMGLPROGRAMUNIFORM4FEXTPROC __rglgen_glProgramUniform4fEXT; +RGLSYMGLPROGRAMUNIFORM4FVEXTPROC __rglgen_glProgramUniform4fvEXT; +RGLSYMGLPROGRAMUNIFORM4IEXTPROC __rglgen_glProgramUniform4iEXT; +RGLSYMGLPROGRAMUNIFORM4IVEXTPROC __rglgen_glProgramUniform4ivEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2FVEXTPROC __rglgen_glProgramUniformMatrix2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3FVEXTPROC __rglgen_glProgramUniformMatrix3fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4FVEXTPROC __rglgen_glProgramUniformMatrix4fvEXT; +RGLSYMGLUSEPROGRAMSTAGESEXTPROC __rglgen_glUseProgramStagesEXT; +RGLSYMGLVALIDATEPROGRAMPIPELINEEXTPROC __rglgen_glValidateProgramPipelineEXT; +RGLSYMGLPROGRAMUNIFORM1UIEXTPROC __rglgen_glProgramUniform1uiEXT; +RGLSYMGLPROGRAMUNIFORM2UIEXTPROC __rglgen_glProgramUniform2uiEXT; +RGLSYMGLPROGRAMUNIFORM3UIEXTPROC __rglgen_glProgramUniform3uiEXT; +RGLSYMGLPROGRAMUNIFORM4UIEXTPROC __rglgen_glProgramUniform4uiEXT; +RGLSYMGLPROGRAMUNIFORM1UIVEXTPROC __rglgen_glProgramUniform1uivEXT; +RGLSYMGLPROGRAMUNIFORM2UIVEXTPROC __rglgen_glProgramUniform2uivEXT; +RGLSYMGLPROGRAMUNIFORM3UIVEXTPROC __rglgen_glProgramUniform3uivEXT; +RGLSYMGLPROGRAMUNIFORM4UIVEXTPROC __rglgen_glProgramUniform4uivEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __rglgen_glProgramUniformMatrix2x3fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __rglgen_glProgramUniformMatrix3x2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __rglgen_glProgramUniformMatrix2x4fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __rglgen_glProgramUniformMatrix4x2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __rglgen_glProgramUniformMatrix3x4fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __rglgen_glProgramUniformMatrix4x3fvEXT; +RGLSYMGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __rglgen_glFramebufferPixelLocalStorageSizeEXT; +RGLSYMGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __rglgen_glGetFramebufferPixelLocalStorageSizeEXT; +RGLSYMGLCLEARPIXELLOCALSTORAGEUIEXTPROC __rglgen_glClearPixelLocalStorageuiEXT; +RGLSYMGLTEXPAGECOMMITMENTEXTPROC __rglgen_glTexPageCommitmentEXT; +RGLSYMGLPATCHPARAMETERIEXTPROC __rglgen_glPatchParameteriEXT; +RGLSYMGLTEXPARAMETERIIVEXTPROC __rglgen_glTexParameterIivEXT; +RGLSYMGLTEXPARAMETERIUIVEXTPROC __rglgen_glTexParameterIuivEXT; +RGLSYMGLGETTEXPARAMETERIIVEXTPROC __rglgen_glGetTexParameterIivEXT; +RGLSYMGLGETTEXPARAMETERIUIVEXTPROC __rglgen_glGetTexParameterIuivEXT; +RGLSYMGLSAMPLERPARAMETERIIVEXTPROC __rglgen_glSamplerParameterIivEXT; +RGLSYMGLSAMPLERPARAMETERIUIVEXTPROC __rglgen_glSamplerParameterIuivEXT; +RGLSYMGLGETSAMPLERPARAMETERIIVEXTPROC __rglgen_glGetSamplerParameterIivEXT; +RGLSYMGLGETSAMPLERPARAMETERIUIVEXTPROC __rglgen_glGetSamplerParameterIuivEXT; +RGLSYMGLTEXBUFFEREXTPROC __rglgen_glTexBufferEXT; +RGLSYMGLTEXBUFFERRANGEEXTPROC __rglgen_glTexBufferRangeEXT; +RGLSYMGLTEXSTORAGE1DEXTPROC __rglgen_glTexStorage1DEXT; +RGLSYMGLTEXSTORAGE2DEXTPROC __rglgen_glTexStorage2DEXT; +RGLSYMGLTEXSTORAGE3DEXTPROC __rglgen_glTexStorage3DEXT; +RGLSYMGLTEXTURESTORAGE1DEXTPROC __rglgen_glTextureStorage1DEXT; +RGLSYMGLTEXTURESTORAGE2DEXTPROC __rglgen_glTextureStorage2DEXT; +RGLSYMGLTEXTURESTORAGE3DEXTPROC __rglgen_glTextureStorage3DEXT; +RGLSYMGLTEXTUREVIEWEXTPROC __rglgen_glTextureViewEXT; +RGLSYMGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __rglgen_glFramebufferTextureMultiviewOVR; +RGLSYMGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __rglgen_glFramebufferTextureMultisampleMultiviewOVR; diff --git a/src/libretro/libretro-common/glsym/glsym_es3.c b/src/libretro/libretro-common/glsym/glsym_es3.c new file mode 100644 index 00000000..86d46d9e --- /dev/null +++ b/src/libretro/libretro-common/glsym/glsym_es3.c @@ -0,0 +1,413 @@ +#include "glsym/glsym.h" +#include +#define SYM(x) { "gl" #x, &(gl##x) } +const struct rglgen_sym_map rglgen_symbol_map[] = { + SYM(BlendBarrierKHR), + SYM(DebugMessageControlKHR), + SYM(DebugMessageInsertKHR), + SYM(DebugMessageCallbackKHR), + SYM(GetDebugMessageLogKHR), + SYM(PushDebugGroupKHR), + SYM(PopDebugGroupKHR), + SYM(ObjectLabelKHR), + SYM(GetObjectLabelKHR), + SYM(ObjectPtrLabelKHR), + SYM(GetObjectPtrLabelKHR), + SYM(GetPointervKHR), + SYM(GetGraphicsResetStatusKHR), + SYM(ReadnPixelsKHR), + SYM(GetnUniformfvKHR), + SYM(GetnUniformivKHR), + SYM(GetnUniformuivKHR), + SYM(EGLImageTargetTexture2DOES), + SYM(EGLImageTargetRenderbufferStorageOES), + SYM(CopyImageSubDataOES), + SYM(EnableiOES), + SYM(DisableiOES), + SYM(BlendEquationiOES), + SYM(BlendEquationSeparateiOES), + SYM(BlendFunciOES), + SYM(BlendFuncSeparateiOES), + SYM(ColorMaskiOES), + SYM(IsEnablediOES), + SYM(DrawElementsBaseVertexOES), + SYM(DrawRangeElementsBaseVertexOES), + SYM(DrawElementsInstancedBaseVertexOES), + SYM(MultiDrawElementsBaseVertexOES), + SYM(FramebufferTextureOES), + SYM(GetProgramBinaryOES), + SYM(ProgramBinaryOES), + SYM(MapBufferOES), + SYM(UnmapBufferOES), + SYM(GetBufferPointervOES), + SYM(PrimitiveBoundingBoxOES), + SYM(MinSampleShadingOES), + SYM(PatchParameteriOES), + SYM(TexImage3DOES), + SYM(TexSubImage3DOES), + SYM(CopyTexSubImage3DOES), + SYM(CompressedTexImage3DOES), + SYM(CompressedTexSubImage3DOES), + SYM(FramebufferTexture3DOES), + SYM(TexParameterIivOES), + SYM(TexParameterIuivOES), + SYM(GetTexParameterIivOES), + SYM(GetTexParameterIuivOES), + SYM(SamplerParameterIivOES), + SYM(SamplerParameterIuivOES), + SYM(GetSamplerParameterIivOES), + SYM(GetSamplerParameterIuivOES), + SYM(TexBufferOES), + SYM(TexBufferRangeOES), + SYM(TexStorage3DMultisampleOES), + SYM(TextureViewOES), + SYM(BindVertexArrayOES), + SYM(DeleteVertexArraysOES), + SYM(GenVertexArraysOES), + SYM(IsVertexArrayOES), + SYM(ViewportArrayvOES), + SYM(ViewportIndexedfOES), + SYM(ViewportIndexedfvOES), + SYM(ScissorArrayvOES), + SYM(ScissorIndexedOES), + SYM(ScissorIndexedvOES), + SYM(DepthRangeArrayfvOES), + SYM(DepthRangeIndexedfOES), + SYM(GetFloati_vOES), + SYM(DrawArraysInstancedBaseInstanceEXT), + SYM(DrawElementsInstancedBaseInstanceEXT), + SYM(DrawElementsInstancedBaseVertexBaseInstanceEXT), + SYM(BindFragDataLocationIndexedEXT), + SYM(BindFragDataLocationEXT), + SYM(GetProgramResourceLocationIndexEXT), + SYM(GetFragDataIndexEXT), + SYM(BufferStorageEXT), + SYM(ClearTexImageEXT), + SYM(ClearTexSubImageEXT), + SYM(CopyImageSubDataEXT), + SYM(LabelObjectEXT), + SYM(GetObjectLabelEXT), + SYM(InsertEventMarkerEXT), + SYM(PushGroupMarkerEXT), + SYM(PopGroupMarkerEXT), + SYM(DiscardFramebufferEXT), + SYM(GenQueriesEXT), + SYM(DeleteQueriesEXT), + SYM(IsQueryEXT), + SYM(BeginQueryEXT), + SYM(EndQueryEXT), + SYM(QueryCounterEXT), + SYM(GetQueryivEXT), + SYM(GetQueryObjectivEXT), + SYM(GetQueryObjectuivEXT), + SYM(GetQueryObjecti64vEXT), + SYM(GetQueryObjectui64vEXT), + SYM(DrawBuffersEXT), + SYM(EnableiEXT), + SYM(DisableiEXT), + SYM(BlendEquationiEXT), + SYM(BlendEquationSeparateiEXT), + SYM(BlendFunciEXT), + SYM(BlendFuncSeparateiEXT), + SYM(ColorMaskiEXT), + SYM(IsEnablediEXT), + SYM(DrawElementsBaseVertexEXT), + SYM(DrawRangeElementsBaseVertexEXT), + SYM(DrawElementsInstancedBaseVertexEXT), + SYM(MultiDrawElementsBaseVertexEXT), + SYM(DrawArraysInstancedEXT), + SYM(DrawElementsInstancedEXT), + SYM(FramebufferTextureEXT), + SYM(VertexAttribDivisorEXT), + SYM(MapBufferRangeEXT), + SYM(FlushMappedBufferRangeEXT), + SYM(MultiDrawArraysEXT), + SYM(MultiDrawElementsEXT), + SYM(MultiDrawArraysIndirectEXT), + SYM(MultiDrawElementsIndirectEXT), + SYM(RenderbufferStorageMultisampleEXT), + SYM(FramebufferTexture2DMultisampleEXT), + SYM(ReadBufferIndexedEXT), + SYM(DrawBuffersIndexedEXT), + SYM(GetIntegeri_vEXT), + SYM(PolygonOffsetClampEXT), + SYM(PrimitiveBoundingBoxEXT), + SYM(RasterSamplesEXT), + SYM(GetGraphicsResetStatusEXT), + SYM(ReadnPixelsEXT), + SYM(GetnUniformfvEXT), + SYM(GetnUniformivEXT), + SYM(ActiveShaderProgramEXT), + SYM(BindProgramPipelineEXT), + SYM(CreateShaderProgramvEXT), + SYM(DeleteProgramPipelinesEXT), + SYM(GenProgramPipelinesEXT), + SYM(GetProgramPipelineInfoLogEXT), + SYM(GetProgramPipelineivEXT), + SYM(IsProgramPipelineEXT), + SYM(ProgramParameteriEXT), + SYM(ProgramUniform1fEXT), + SYM(ProgramUniform1fvEXT), + SYM(ProgramUniform1iEXT), + SYM(ProgramUniform1ivEXT), + SYM(ProgramUniform2fEXT), + SYM(ProgramUniform2fvEXT), + SYM(ProgramUniform2iEXT), + SYM(ProgramUniform2ivEXT), + SYM(ProgramUniform3fEXT), + SYM(ProgramUniform3fvEXT), + SYM(ProgramUniform3iEXT), + SYM(ProgramUniform3ivEXT), + SYM(ProgramUniform4fEXT), + SYM(ProgramUniform4fvEXT), + SYM(ProgramUniform4iEXT), + SYM(ProgramUniform4ivEXT), + SYM(ProgramUniformMatrix2fvEXT), + SYM(ProgramUniformMatrix3fvEXT), + SYM(ProgramUniformMatrix4fvEXT), + SYM(UseProgramStagesEXT), + SYM(ValidateProgramPipelineEXT), + SYM(ProgramUniform1uiEXT), + SYM(ProgramUniform2uiEXT), + SYM(ProgramUniform3uiEXT), + SYM(ProgramUniform4uiEXT), + SYM(ProgramUniform1uivEXT), + SYM(ProgramUniform2uivEXT), + SYM(ProgramUniform3uivEXT), + SYM(ProgramUniform4uivEXT), + SYM(ProgramUniformMatrix2x3fvEXT), + SYM(ProgramUniformMatrix3x2fvEXT), + SYM(ProgramUniformMatrix2x4fvEXT), + SYM(ProgramUniformMatrix4x2fvEXT), + SYM(ProgramUniformMatrix3x4fvEXT), + SYM(ProgramUniformMatrix4x3fvEXT), + SYM(FramebufferPixelLocalStorageSizeEXT), + SYM(GetFramebufferPixelLocalStorageSizeEXT), + SYM(ClearPixelLocalStorageuiEXT), + SYM(TexPageCommitmentEXT), + SYM(PatchParameteriEXT), + SYM(TexParameterIivEXT), + SYM(TexParameterIuivEXT), + SYM(GetTexParameterIivEXT), + SYM(GetTexParameterIuivEXT), + SYM(SamplerParameterIivEXT), + SYM(SamplerParameterIuivEXT), + SYM(GetSamplerParameterIivEXT), + SYM(GetSamplerParameterIuivEXT), + SYM(TexBufferEXT), + SYM(TexBufferRangeEXT), + SYM(TexStorage1DEXT), + SYM(TexStorage2DEXT), + SYM(TexStorage3DEXT), + SYM(TextureStorage1DEXT), + SYM(TextureStorage2DEXT), + SYM(TextureStorage3DEXT), + SYM(TextureViewEXT), + SYM(FramebufferTextureMultiviewOVR), + SYM(FramebufferTextureMultisampleMultiviewOVR), + + { NULL, NULL }, +}; +RGLSYMGLBLENDBARRIERKHRPROC __rglgen_glBlendBarrierKHR; +RGLSYMGLDEBUGMESSAGECONTROLKHRPROC __rglgen_glDebugMessageControlKHR; +RGLSYMGLDEBUGMESSAGEINSERTKHRPROC __rglgen_glDebugMessageInsertKHR; +RGLSYMGLDEBUGMESSAGECALLBACKKHRPROC __rglgen_glDebugMessageCallbackKHR; +RGLSYMGLGETDEBUGMESSAGELOGKHRPROC __rglgen_glGetDebugMessageLogKHR; +RGLSYMGLPUSHDEBUGGROUPKHRPROC __rglgen_glPushDebugGroupKHR; +RGLSYMGLPOPDEBUGGROUPKHRPROC __rglgen_glPopDebugGroupKHR; +RGLSYMGLOBJECTLABELKHRPROC __rglgen_glObjectLabelKHR; +RGLSYMGLGETOBJECTLABELKHRPROC __rglgen_glGetObjectLabelKHR; +RGLSYMGLOBJECTPTRLABELKHRPROC __rglgen_glObjectPtrLabelKHR; +RGLSYMGLGETOBJECTPTRLABELKHRPROC __rglgen_glGetObjectPtrLabelKHR; +RGLSYMGLGETPOINTERVKHRPROC __rglgen_glGetPointervKHR; +RGLSYMGLGETGRAPHICSRESETSTATUSKHRPROC __rglgen_glGetGraphicsResetStatusKHR; +RGLSYMGLREADNPIXELSKHRPROC __rglgen_glReadnPixelsKHR; +RGLSYMGLGETNUNIFORMFVKHRPROC __rglgen_glGetnUniformfvKHR; +RGLSYMGLGETNUNIFORMIVKHRPROC __rglgen_glGetnUniformivKHR; +RGLSYMGLGETNUNIFORMUIVKHRPROC __rglgen_glGetnUniformuivKHR; +RGLSYMGLEGLIMAGETARGETTEXTURE2DOESPROC __rglgen_glEGLImageTargetTexture2DOES; +RGLSYMGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC __rglgen_glEGLImageTargetRenderbufferStorageOES; +RGLSYMGLCOPYIMAGESUBDATAOESPROC __rglgen_glCopyImageSubDataOES; +RGLSYMGLENABLEIOESPROC __rglgen_glEnableiOES; +RGLSYMGLDISABLEIOESPROC __rglgen_glDisableiOES; +RGLSYMGLBLENDEQUATIONIOESPROC __rglgen_glBlendEquationiOES; +RGLSYMGLBLENDEQUATIONSEPARATEIOESPROC __rglgen_glBlendEquationSeparateiOES; +RGLSYMGLBLENDFUNCIOESPROC __rglgen_glBlendFunciOES; +RGLSYMGLBLENDFUNCSEPARATEIOESPROC __rglgen_glBlendFuncSeparateiOES; +RGLSYMGLCOLORMASKIOESPROC __rglgen_glColorMaskiOES; +RGLSYMGLISENABLEDIOESPROC __rglgen_glIsEnablediOES; +RGLSYMGLDRAWELEMENTSBASEVERTEXOESPROC __rglgen_glDrawElementsBaseVertexOES; +RGLSYMGLDRAWRANGEELEMENTSBASEVERTEXOESPROC __rglgen_glDrawRangeElementsBaseVertexOES; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXOESPROC __rglgen_glDrawElementsInstancedBaseVertexOES; +RGLSYMGLMULTIDRAWELEMENTSBASEVERTEXOESPROC __rglgen_glMultiDrawElementsBaseVertexOES; +RGLSYMGLFRAMEBUFFERTEXTUREOESPROC __rglgen_glFramebufferTextureOES; +RGLSYMGLGETPROGRAMBINARYOESPROC __rglgen_glGetProgramBinaryOES; +RGLSYMGLPROGRAMBINARYOESPROC __rglgen_glProgramBinaryOES; +RGLSYMGLMAPBUFFEROESPROC __rglgen_glMapBufferOES; +RGLSYMGLUNMAPBUFFEROESPROC __rglgen_glUnmapBufferOES; +RGLSYMGLGETBUFFERPOINTERVOESPROC __rglgen_glGetBufferPointervOES; +RGLSYMGLPRIMITIVEBOUNDINGBOXOESPROC __rglgen_glPrimitiveBoundingBoxOES; +RGLSYMGLMINSAMPLESHADINGOESPROC __rglgen_glMinSampleShadingOES; +RGLSYMGLPATCHPARAMETERIOESPROC __rglgen_glPatchParameteriOES; +RGLSYMGLTEXIMAGE3DOESPROC __rglgen_glTexImage3DOES; +RGLSYMGLTEXSUBIMAGE3DOESPROC __rglgen_glTexSubImage3DOES; +RGLSYMGLCOPYTEXSUBIMAGE3DOESPROC __rglgen_glCopyTexSubImage3DOES; +RGLSYMGLCOMPRESSEDTEXIMAGE3DOESPROC __rglgen_glCompressedTexImage3DOES; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE3DOESPROC __rglgen_glCompressedTexSubImage3DOES; +RGLSYMGLFRAMEBUFFERTEXTURE3DOESPROC __rglgen_glFramebufferTexture3DOES; +RGLSYMGLTEXPARAMETERIIVOESPROC __rglgen_glTexParameterIivOES; +RGLSYMGLTEXPARAMETERIUIVOESPROC __rglgen_glTexParameterIuivOES; +RGLSYMGLGETTEXPARAMETERIIVOESPROC __rglgen_glGetTexParameterIivOES; +RGLSYMGLGETTEXPARAMETERIUIVOESPROC __rglgen_glGetTexParameterIuivOES; +RGLSYMGLSAMPLERPARAMETERIIVOESPROC __rglgen_glSamplerParameterIivOES; +RGLSYMGLSAMPLERPARAMETERIUIVOESPROC __rglgen_glSamplerParameterIuivOES; +RGLSYMGLGETSAMPLERPARAMETERIIVOESPROC __rglgen_glGetSamplerParameterIivOES; +RGLSYMGLGETSAMPLERPARAMETERIUIVOESPROC __rglgen_glGetSamplerParameterIuivOES; +RGLSYMGLTEXBUFFEROESPROC __rglgen_glTexBufferOES; +RGLSYMGLTEXBUFFERRANGEOESPROC __rglgen_glTexBufferRangeOES; +RGLSYMGLTEXSTORAGE3DMULTISAMPLEOESPROC __rglgen_glTexStorage3DMultisampleOES; +RGLSYMGLTEXTUREVIEWOESPROC __rglgen_glTextureViewOES; +RGLSYMGLBINDVERTEXARRAYOESPROC __rglgen_glBindVertexArrayOES; +RGLSYMGLDELETEVERTEXARRAYSOESPROC __rglgen_glDeleteVertexArraysOES; +RGLSYMGLGENVERTEXARRAYSOESPROC __rglgen_glGenVertexArraysOES; +RGLSYMGLISVERTEXARRAYOESPROC __rglgen_glIsVertexArrayOES; +RGLSYMGLVIEWPORTARRAYVOESPROC __rglgen_glViewportArrayvOES; +RGLSYMGLVIEWPORTINDEXEDFOESPROC __rglgen_glViewportIndexedfOES; +RGLSYMGLVIEWPORTINDEXEDFVOESPROC __rglgen_glViewportIndexedfvOES; +RGLSYMGLSCISSORARRAYVOESPROC __rglgen_glScissorArrayvOES; +RGLSYMGLSCISSORINDEXEDOESPROC __rglgen_glScissorIndexedOES; +RGLSYMGLSCISSORINDEXEDVOESPROC __rglgen_glScissorIndexedvOES; +RGLSYMGLDEPTHRANGEARRAYFVOESPROC __rglgen_glDepthRangeArrayfvOES; +RGLSYMGLDEPTHRANGEINDEXEDFOESPROC __rglgen_glDepthRangeIndexedfOES; +RGLSYMGLGETFLOATI_VOESPROC __rglgen_glGetFloati_vOES; +RGLSYMGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __rglgen_glDrawArraysInstancedBaseInstanceEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __rglgen_glDrawElementsInstancedBaseInstanceEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __rglgen_glDrawElementsInstancedBaseVertexBaseInstanceEXT; +RGLSYMGLBINDFRAGDATALOCATIONINDEXEDEXTPROC __rglgen_glBindFragDataLocationIndexedEXT; +RGLSYMGLBINDFRAGDATALOCATIONEXTPROC __rglgen_glBindFragDataLocationEXT; +RGLSYMGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC __rglgen_glGetProgramResourceLocationIndexEXT; +RGLSYMGLGETFRAGDATAINDEXEXTPROC __rglgen_glGetFragDataIndexEXT; +RGLSYMGLBUFFERSTORAGEEXTPROC __rglgen_glBufferStorageEXT; +RGLSYMGLCLEARTEXIMAGEEXTPROC __rglgen_glClearTexImageEXT; +RGLSYMGLCLEARTEXSUBIMAGEEXTPROC __rglgen_glClearTexSubImageEXT; +RGLSYMGLCOPYIMAGESUBDATAEXTPROC __rglgen_glCopyImageSubDataEXT; +RGLSYMGLLABELOBJECTEXTPROC __rglgen_glLabelObjectEXT; +RGLSYMGLGETOBJECTLABELEXTPROC __rglgen_glGetObjectLabelEXT; +RGLSYMGLINSERTEVENTMARKEREXTPROC __rglgen_glInsertEventMarkerEXT; +RGLSYMGLPUSHGROUPMARKEREXTPROC __rglgen_glPushGroupMarkerEXT; +RGLSYMGLPOPGROUPMARKEREXTPROC __rglgen_glPopGroupMarkerEXT; +RGLSYMGLDISCARDFRAMEBUFFEREXTPROC __rglgen_glDiscardFramebufferEXT; +RGLSYMGLGENQUERIESEXTPROC __rglgen_glGenQueriesEXT; +RGLSYMGLDELETEQUERIESEXTPROC __rglgen_glDeleteQueriesEXT; +RGLSYMGLISQUERYEXTPROC __rglgen_glIsQueryEXT; +RGLSYMGLBEGINQUERYEXTPROC __rglgen_glBeginQueryEXT; +RGLSYMGLENDQUERYEXTPROC __rglgen_glEndQueryEXT; +RGLSYMGLQUERYCOUNTEREXTPROC __rglgen_glQueryCounterEXT; +RGLSYMGLGETQUERYIVEXTPROC __rglgen_glGetQueryivEXT; +RGLSYMGLGETQUERYOBJECTIVEXTPROC __rglgen_glGetQueryObjectivEXT; +RGLSYMGLGETQUERYOBJECTUIVEXTPROC __rglgen_glGetQueryObjectuivEXT; +RGLSYMGLGETQUERYOBJECTI64VEXTPROC __rglgen_glGetQueryObjecti64vEXT; +RGLSYMGLGETQUERYOBJECTUI64VEXTPROC __rglgen_glGetQueryObjectui64vEXT; +RGLSYMGLDRAWBUFFERSEXTPROC __rglgen_glDrawBuffersEXT; +RGLSYMGLENABLEIEXTPROC __rglgen_glEnableiEXT; +RGLSYMGLDISABLEIEXTPROC __rglgen_glDisableiEXT; +RGLSYMGLBLENDEQUATIONIEXTPROC __rglgen_glBlendEquationiEXT; +RGLSYMGLBLENDEQUATIONSEPARATEIEXTPROC __rglgen_glBlendEquationSeparateiEXT; +RGLSYMGLBLENDFUNCIEXTPROC __rglgen_glBlendFunciEXT; +RGLSYMGLBLENDFUNCSEPARATEIEXTPROC __rglgen_glBlendFuncSeparateiEXT; +RGLSYMGLCOLORMASKIEXTPROC __rglgen_glColorMaskiEXT; +RGLSYMGLISENABLEDIEXTPROC __rglgen_glIsEnablediEXT; +RGLSYMGLDRAWELEMENTSBASEVERTEXEXTPROC __rglgen_glDrawElementsBaseVertexEXT; +RGLSYMGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC __rglgen_glDrawRangeElementsBaseVertexEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC __rglgen_glDrawElementsInstancedBaseVertexEXT; +RGLSYMGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC __rglgen_glMultiDrawElementsBaseVertexEXT; +RGLSYMGLDRAWARRAYSINSTANCEDEXTPROC __rglgen_glDrawArraysInstancedEXT; +RGLSYMGLDRAWELEMENTSINSTANCEDEXTPROC __rglgen_glDrawElementsInstancedEXT; +RGLSYMGLFRAMEBUFFERTEXTUREEXTPROC __rglgen_glFramebufferTextureEXT; +RGLSYMGLVERTEXATTRIBDIVISOREXTPROC __rglgen_glVertexAttribDivisorEXT; +RGLSYMGLMAPBUFFERRANGEEXTPROC __rglgen_glMapBufferRangeEXT; +RGLSYMGLFLUSHMAPPEDBUFFERRANGEEXTPROC __rglgen_glFlushMappedBufferRangeEXT; +RGLSYMGLMULTIDRAWARRAYSEXTPROC __rglgen_glMultiDrawArraysEXT; +RGLSYMGLMULTIDRAWELEMENTSEXTPROC __rglgen_glMultiDrawElementsEXT; +RGLSYMGLMULTIDRAWARRAYSINDIRECTEXTPROC __rglgen_glMultiDrawArraysIndirectEXT; +RGLSYMGLMULTIDRAWELEMENTSINDIRECTEXTPROC __rglgen_glMultiDrawElementsIndirectEXT; +RGLSYMGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __rglgen_glRenderbufferStorageMultisampleEXT; +RGLSYMGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC __rglgen_glFramebufferTexture2DMultisampleEXT; +RGLSYMGLREADBUFFERINDEXEDEXTPROC __rglgen_glReadBufferIndexedEXT; +RGLSYMGLDRAWBUFFERSINDEXEDEXTPROC __rglgen_glDrawBuffersIndexedEXT; +RGLSYMGLGETINTEGERI_VEXTPROC __rglgen_glGetIntegeri_vEXT; +RGLSYMGLPOLYGONOFFSETCLAMPEXTPROC __rglgen_glPolygonOffsetClampEXT; +RGLSYMGLPRIMITIVEBOUNDINGBOXEXTPROC __rglgen_glPrimitiveBoundingBoxEXT; +RGLSYMGLRASTERSAMPLESEXTPROC __rglgen_glRasterSamplesEXT; +RGLSYMGLGETGRAPHICSRESETSTATUSEXTPROC __rglgen_glGetGraphicsResetStatusEXT; +RGLSYMGLREADNPIXELSEXTPROC __rglgen_glReadnPixelsEXT; +RGLSYMGLGETNUNIFORMFVEXTPROC __rglgen_glGetnUniformfvEXT; +RGLSYMGLGETNUNIFORMIVEXTPROC __rglgen_glGetnUniformivEXT; +RGLSYMGLACTIVESHADERPROGRAMEXTPROC __rglgen_glActiveShaderProgramEXT; +RGLSYMGLBINDPROGRAMPIPELINEEXTPROC __rglgen_glBindProgramPipelineEXT; +RGLSYMGLCREATESHADERPROGRAMVEXTPROC __rglgen_glCreateShaderProgramvEXT; +RGLSYMGLDELETEPROGRAMPIPELINESEXTPROC __rglgen_glDeleteProgramPipelinesEXT; +RGLSYMGLGENPROGRAMPIPELINESEXTPROC __rglgen_glGenProgramPipelinesEXT; +RGLSYMGLGETPROGRAMPIPELINEINFOLOGEXTPROC __rglgen_glGetProgramPipelineInfoLogEXT; +RGLSYMGLGETPROGRAMPIPELINEIVEXTPROC __rglgen_glGetProgramPipelineivEXT; +RGLSYMGLISPROGRAMPIPELINEEXTPROC __rglgen_glIsProgramPipelineEXT; +RGLSYMGLPROGRAMPARAMETERIEXTPROC __rglgen_glProgramParameteriEXT; +RGLSYMGLPROGRAMUNIFORM1FEXTPROC __rglgen_glProgramUniform1fEXT; +RGLSYMGLPROGRAMUNIFORM1FVEXTPROC __rglgen_glProgramUniform1fvEXT; +RGLSYMGLPROGRAMUNIFORM1IEXTPROC __rglgen_glProgramUniform1iEXT; +RGLSYMGLPROGRAMUNIFORM1IVEXTPROC __rglgen_glProgramUniform1ivEXT; +RGLSYMGLPROGRAMUNIFORM2FEXTPROC __rglgen_glProgramUniform2fEXT; +RGLSYMGLPROGRAMUNIFORM2FVEXTPROC __rglgen_glProgramUniform2fvEXT; +RGLSYMGLPROGRAMUNIFORM2IEXTPROC __rglgen_glProgramUniform2iEXT; +RGLSYMGLPROGRAMUNIFORM2IVEXTPROC __rglgen_glProgramUniform2ivEXT; +RGLSYMGLPROGRAMUNIFORM3FEXTPROC __rglgen_glProgramUniform3fEXT; +RGLSYMGLPROGRAMUNIFORM3FVEXTPROC __rglgen_glProgramUniform3fvEXT; +RGLSYMGLPROGRAMUNIFORM3IEXTPROC __rglgen_glProgramUniform3iEXT; +RGLSYMGLPROGRAMUNIFORM3IVEXTPROC __rglgen_glProgramUniform3ivEXT; +RGLSYMGLPROGRAMUNIFORM4FEXTPROC __rglgen_glProgramUniform4fEXT; +RGLSYMGLPROGRAMUNIFORM4FVEXTPROC __rglgen_glProgramUniform4fvEXT; +RGLSYMGLPROGRAMUNIFORM4IEXTPROC __rglgen_glProgramUniform4iEXT; +RGLSYMGLPROGRAMUNIFORM4IVEXTPROC __rglgen_glProgramUniform4ivEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2FVEXTPROC __rglgen_glProgramUniformMatrix2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3FVEXTPROC __rglgen_glProgramUniformMatrix3fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4FVEXTPROC __rglgen_glProgramUniformMatrix4fvEXT; +RGLSYMGLUSEPROGRAMSTAGESEXTPROC __rglgen_glUseProgramStagesEXT; +RGLSYMGLVALIDATEPROGRAMPIPELINEEXTPROC __rglgen_glValidateProgramPipelineEXT; +RGLSYMGLPROGRAMUNIFORM1UIEXTPROC __rglgen_glProgramUniform1uiEXT; +RGLSYMGLPROGRAMUNIFORM2UIEXTPROC __rglgen_glProgramUniform2uiEXT; +RGLSYMGLPROGRAMUNIFORM3UIEXTPROC __rglgen_glProgramUniform3uiEXT; +RGLSYMGLPROGRAMUNIFORM4UIEXTPROC __rglgen_glProgramUniform4uiEXT; +RGLSYMGLPROGRAMUNIFORM1UIVEXTPROC __rglgen_glProgramUniform1uivEXT; +RGLSYMGLPROGRAMUNIFORM2UIVEXTPROC __rglgen_glProgramUniform2uivEXT; +RGLSYMGLPROGRAMUNIFORM3UIVEXTPROC __rglgen_glProgramUniform3uivEXT; +RGLSYMGLPROGRAMUNIFORM4UIVEXTPROC __rglgen_glProgramUniform4uivEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __rglgen_glProgramUniformMatrix2x3fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __rglgen_glProgramUniformMatrix3x2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __rglgen_glProgramUniformMatrix2x4fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __rglgen_glProgramUniformMatrix4x2fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __rglgen_glProgramUniformMatrix3x4fvEXT; +RGLSYMGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __rglgen_glProgramUniformMatrix4x3fvEXT; +RGLSYMGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __rglgen_glFramebufferPixelLocalStorageSizeEXT; +RGLSYMGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __rglgen_glGetFramebufferPixelLocalStorageSizeEXT; +RGLSYMGLCLEARPIXELLOCALSTORAGEUIEXTPROC __rglgen_glClearPixelLocalStorageuiEXT; +RGLSYMGLTEXPAGECOMMITMENTEXTPROC __rglgen_glTexPageCommitmentEXT; +RGLSYMGLPATCHPARAMETERIEXTPROC __rglgen_glPatchParameteriEXT; +RGLSYMGLTEXPARAMETERIIVEXTPROC __rglgen_glTexParameterIivEXT; +RGLSYMGLTEXPARAMETERIUIVEXTPROC __rglgen_glTexParameterIuivEXT; +RGLSYMGLGETTEXPARAMETERIIVEXTPROC __rglgen_glGetTexParameterIivEXT; +RGLSYMGLGETTEXPARAMETERIUIVEXTPROC __rglgen_glGetTexParameterIuivEXT; +RGLSYMGLSAMPLERPARAMETERIIVEXTPROC __rglgen_glSamplerParameterIivEXT; +RGLSYMGLSAMPLERPARAMETERIUIVEXTPROC __rglgen_glSamplerParameterIuivEXT; +RGLSYMGLGETSAMPLERPARAMETERIIVEXTPROC __rglgen_glGetSamplerParameterIivEXT; +RGLSYMGLGETSAMPLERPARAMETERIUIVEXTPROC __rglgen_glGetSamplerParameterIuivEXT; +RGLSYMGLTEXBUFFEREXTPROC __rglgen_glTexBufferEXT; +RGLSYMGLTEXBUFFERRANGEEXTPROC __rglgen_glTexBufferRangeEXT; +RGLSYMGLTEXSTORAGE1DEXTPROC __rglgen_glTexStorage1DEXT; +RGLSYMGLTEXSTORAGE2DEXTPROC __rglgen_glTexStorage2DEXT; +RGLSYMGLTEXSTORAGE3DEXTPROC __rglgen_glTexStorage3DEXT; +RGLSYMGLTEXTURESTORAGE1DEXTPROC __rglgen_glTextureStorage1DEXT; +RGLSYMGLTEXTURESTORAGE2DEXTPROC __rglgen_glTextureStorage2DEXT; +RGLSYMGLTEXTURESTORAGE3DEXTPROC __rglgen_glTextureStorage3DEXT; +RGLSYMGLTEXTUREVIEWEXTPROC __rglgen_glTextureViewEXT; +RGLSYMGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __rglgen_glFramebufferTextureMultiviewOVR; +RGLSYMGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __rglgen_glFramebufferTextureMultisampleMultiviewOVR; diff --git a/src/libretro/libretro-common/glsym/glsym_gl.c b/src/libretro/libretro-common/glsym/glsym_gl.c new file mode 100644 index 00000000..a5ce04e8 --- /dev/null +++ b/src/libretro/libretro-common/glsym/glsym_gl.c @@ -0,0 +1,2541 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this libretro SDK code part (glsym). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include + +#include + +#define SYM(x) { "gl" #x, (void*)&(gl##x) } + +const struct rglgen_sym_map rglgen_symbol_map[] = { +#ifdef HAVE_LIBNX + SYM(ClearIndex), + SYM(ClearColor), + SYM(Clear), + SYM(IndexMask), + SYM(ColorMask), + SYM(AlphaFunc), + SYM(BlendFunc), + SYM(LogicOp), + SYM(CullFace), + SYM(FrontFace), + SYM(PointSize), + SYM(LineWidth), + SYM(LineStipple), + SYM(PolygonMode), + SYM(PolygonOffset), + SYM(PolygonStipple), + SYM(GetPolygonStipple), + SYM(EdgeFlag), + SYM(EdgeFlagv), + SYM(Scissor), + SYM(ClipPlane), + SYM(GetClipPlane), + SYM(DrawBuffer), + SYM(ReadBuffer), + SYM(Enable), + SYM(Disable), + SYM(IsEnabled), + SYM(EnableClientState), + SYM(DisableClientState), + SYM(GetBooleanv), + SYM(GetDoublev), + SYM(GetFloatv), + SYM(GetIntegerv), + SYM(PushAttrib), + SYM(PopAttrib), + SYM(PushClientAttrib), + SYM(PopClientAttrib), + SYM(RenderMode), + SYM(GetError), + SYM(GetString), + SYM(Finish), + SYM(Flush), + SYM(Hint), + SYM(ClearDepth), + SYM(DepthFunc), + SYM(DepthMask), + SYM(DepthRange), + SYM(ClearAccum), + SYM(Accum), + SYM(MatrixMode), + SYM(Ortho), + SYM(Frustum), + SYM(Viewport), + SYM(PushMatrix), + SYM(PopMatrix), + SYM(LoadIdentity), + SYM(LoadMatrixd), + SYM(LoadMatrixf), + SYM(MultMatrixd), + SYM(MultMatrixf), + SYM(Rotated), + SYM(Rotatef), + SYM(Scaled), + SYM(Scalef), + SYM(Translated), + SYM(Translatef), + SYM(IsList), + SYM(DeleteLists), + SYM(GenLists), + SYM(NewList), + SYM(EndList), + SYM(CallList), + SYM(CallLists), + SYM(ListBase), + SYM(Begin), + SYM(End), + SYM(Vertex2d), + SYM(Vertex2f), + SYM(Vertex2i), + SYM(Vertex2s), + SYM(Vertex3d), + SYM(Vertex3f), + SYM(Vertex3i), + SYM(Vertex3s), + SYM(Vertex4d), + SYM(Vertex4f), + SYM(Vertex4i), + SYM(Vertex4s), + SYM(Vertex2dv), + SYM(Vertex2fv), + SYM(Vertex2iv), + SYM(Vertex2sv), + SYM(Vertex3dv), + SYM(Vertex3fv), + SYM(Vertex3iv), + SYM(Vertex3sv), + SYM(Vertex4dv), + SYM(Vertex4fv), + SYM(Vertex4iv), + SYM(Vertex4sv), + SYM(Normal3b), + SYM(Normal3d), + SYM(Normal3f), + SYM(Normal3i), + SYM(Normal3s), + SYM(Normal3bv), + SYM(Normal3dv), + SYM(Normal3fv), + SYM(Normal3iv), + SYM(Normal3sv), + SYM(Indexd), + SYM(Indexf), + SYM(Indexi), + SYM(Indexs), + SYM(Indexub), + SYM(Indexdv), + SYM(Indexfv), + SYM(Indexiv), + SYM(Indexsv), + SYM(Indexubv), + SYM(Color3b), + SYM(Color3d), + SYM(Color3f), + SYM(Color3i), + SYM(Color3s), + SYM(Color3ub), + SYM(Color3ui), + SYM(Color3us), + SYM(Color4b), + SYM(Color4d), + SYM(Color4f), + SYM(Color4i), + SYM(Color4s), + SYM(Color4ub), + SYM(Color4ui), + SYM(Color4us), + SYM(Color3bv), + SYM(Color3dv), + SYM(Color3fv), + SYM(Color3iv), + SYM(Color3sv), + SYM(Color3ubv), + SYM(Color3uiv), + SYM(Color3usv), + SYM(Color4bv), + SYM(Color4dv), + SYM(Color4fv), + SYM(Color4iv), + SYM(Color4sv), + SYM(Color4ubv), + SYM(Color4uiv), + SYM(Color4usv), + SYM(TexCoord1d), + SYM(TexCoord1f), + SYM(TexCoord1i), + SYM(TexCoord1s), + SYM(TexCoord2d), + SYM(TexCoord2f), + SYM(TexCoord2i), + SYM(TexCoord2s), + SYM(TexCoord3d), + SYM(TexCoord3f), + SYM(TexCoord3i), + SYM(TexCoord3s), + SYM(TexCoord4d), + SYM(TexCoord4f), + SYM(TexCoord4i), + SYM(TexCoord4s), + SYM(TexCoord1dv), + SYM(TexCoord1fv), + SYM(TexCoord1iv), + SYM(TexCoord1sv), + SYM(TexCoord2dv), + SYM(TexCoord2fv), + SYM(TexCoord2iv), + SYM(TexCoord2sv), + SYM(TexCoord3dv), + SYM(TexCoord3fv), + SYM(TexCoord3iv), + SYM(TexCoord3sv), + SYM(TexCoord4dv), + SYM(TexCoord4fv), + SYM(TexCoord4iv), + SYM(TexCoord4sv), + SYM(RasterPos2d), + SYM(RasterPos2f), + SYM(RasterPos2i), + SYM(RasterPos2s), + SYM(RasterPos3d), + SYM(RasterPos3f), + SYM(RasterPos3i), + SYM(RasterPos3s), + SYM(RasterPos4d), + SYM(RasterPos4f), + SYM(RasterPos4i), + SYM(RasterPos4s), + SYM(RasterPos2dv), + SYM(RasterPos2fv), + SYM(RasterPos2iv), + SYM(RasterPos2sv), + SYM(RasterPos3dv), + SYM(RasterPos3fv), + SYM(RasterPos3iv), + SYM(RasterPos3sv), + SYM(RasterPos4dv), + SYM(RasterPos4fv), + SYM(RasterPos4iv), + SYM(RasterPos4sv), + SYM(Rectd), + SYM(Rectf), + SYM(Recti), + SYM(Rects), + SYM(Rectdv), + SYM(Rectfv), + SYM(Rectiv), + SYM(Rectsv), + SYM(VertexPointer), + SYM(NormalPointer), + SYM(ColorPointer), + SYM(IndexPointer), + SYM(TexCoordPointer), + SYM(EdgeFlagPointer), + SYM(GetPointerv), + SYM(ArrayElement), + SYM(DrawArrays), + SYM(DrawElements), + SYM(InterleavedArrays), + SYM(ShadeModel), + SYM(Lightf), + SYM(Lighti), + SYM(Lightfv), + SYM(Lightiv), + SYM(GetLightfv), + SYM(GetLightiv), + SYM(LightModelf), + SYM(LightModeli), + SYM(LightModelfv), + SYM(LightModeliv), + SYM(Materialf), + SYM(Materiali), + SYM(Materialfv), + SYM(Materialiv), + SYM(GetMaterialfv), + SYM(GetMaterialiv), + SYM(ColorMaterial), + SYM(PixelZoom), + SYM(PixelStoref), + SYM(PixelStorei), + SYM(PixelTransferf), + SYM(PixelTransferi), + SYM(PixelMapfv), + SYM(PixelMapuiv), + SYM(PixelMapusv), + SYM(GetPixelMapfv), + SYM(GetPixelMapuiv), + SYM(GetPixelMapusv), + SYM(Bitmap), + SYM(ReadPixels), + SYM(DrawPixels), + SYM(CopyPixels), + SYM(StencilFunc), + SYM(StencilMask), + SYM(StencilOp), + SYM(ClearStencil), + SYM(TexGend), + SYM(TexGenf), + SYM(TexGeni), + SYM(TexGendv), + SYM(TexGenfv), + SYM(TexGeniv), + SYM(GetTexGendv), + SYM(GetTexGenfv), + SYM(GetTexGeniv), + SYM(TexEnvf), + SYM(TexEnvi), + SYM(TexEnvfv), + SYM(TexEnviv), + SYM(GetTexEnvfv), + SYM(GetTexEnviv), + SYM(TexParameterf), + SYM(TexParameteri), + SYM(TexParameterfv), + SYM(TexParameteriv), + SYM(GetTexParameterfv), + SYM(GetTexParameteriv), + SYM(GetTexLevelParameterfv), + SYM(GetTexLevelParameteriv), + SYM(TexImage1D), + SYM(TexImage2D), + SYM(GetTexImage), + SYM(GenTextures), + SYM(DeleteTextures), + SYM(BindTexture), + SYM(PrioritizeTextures), + SYM(AreTexturesResident), + SYM(IsTexture), + SYM(TexSubImage1D), + SYM(TexSubImage2D), + SYM(CopyTexImage1D), + SYM(CopyTexImage2D), + SYM(CopyTexSubImage1D), + SYM(CopyTexSubImage2D), + SYM(Map1d), + SYM(Map1f), + SYM(Map2d), + SYM(Map2f), + SYM(GetMapdv), + SYM(GetMapfv), + SYM(GetMapiv), + SYM(EvalCoord1d), + SYM(EvalCoord1f), + SYM(EvalCoord1dv), + SYM(EvalCoord1fv), + SYM(EvalCoord2d), + SYM(EvalCoord2f), + SYM(EvalCoord2dv), + SYM(EvalCoord2fv), + SYM(MapGrid1d), + SYM(MapGrid1f), + SYM(MapGrid2d), + SYM(MapGrid2f), + SYM(EvalPoint1), + SYM(EvalPoint2), + SYM(EvalMesh1), + SYM(EvalMesh2), + SYM(Fogf), + SYM(Fogi), + SYM(Fogfv), + SYM(Fogiv), + SYM(FeedbackBuffer), + SYM(PassThrough), + SYM(SelectBuffer), + SYM(InitNames), + SYM(LoadName), + SYM(PushName), + SYM(PopName), + SYM(DrawRangeElements), + SYM(TexImage3D), + SYM(TexSubImage3D), + SYM(CopyTexSubImage3D), + SYM(ColorTable), + SYM(ColorSubTable), + SYM(ColorTableParameteriv), + SYM(ColorTableParameterfv), + SYM(CopyColorSubTable), + SYM(CopyColorTable), + SYM(GetColorTable), + SYM(GetColorTableParameterfv), + SYM(GetColorTableParameteriv), + SYM(BlendEquation), + SYM(BlendColor), + SYM(Histogram), + SYM(ResetHistogram), + SYM(GetHistogram), + SYM(GetHistogramParameterfv), + SYM(GetHistogramParameteriv), + SYM(Minmax), + SYM(ResetMinmax), + SYM(GetMinmax), + SYM(GetMinmaxParameterfv), + SYM(GetMinmaxParameteriv), + SYM(ConvolutionFilter1D), + SYM(ConvolutionFilter2D), + SYM(ConvolutionParameterf), + SYM(ConvolutionParameterfv), + SYM(ConvolutionParameteri), + SYM(ConvolutionParameteriv), + SYM(CopyConvolutionFilter1D), + SYM(CopyConvolutionFilter2D), + SYM(GetConvolutionFilter), + SYM(GetConvolutionParameterfv), + SYM(GetConvolutionParameteriv), + SYM(SeparableFilter2D), + SYM(GetSeparableFilter), + SYM(ActiveTexture), + SYM(ClientActiveTexture), + SYM(CompressedTexImage1D), + SYM(CompressedTexImage2D), + SYM(CompressedTexImage3D), + SYM(CompressedTexSubImage1D), + SYM(CompressedTexSubImage2D), + SYM(CompressedTexSubImage3D), + SYM(GetCompressedTexImage), + SYM(MultiTexCoord1d), + SYM(MultiTexCoord1dv), + SYM(MultiTexCoord1f), + SYM(MultiTexCoord1fv), + SYM(MultiTexCoord1i), + SYM(MultiTexCoord1iv), + SYM(MultiTexCoord1s), + SYM(MultiTexCoord1sv), + SYM(MultiTexCoord2d), + SYM(MultiTexCoord2dv), + SYM(MultiTexCoord2f), + SYM(MultiTexCoord2fv), + SYM(MultiTexCoord2i), + SYM(MultiTexCoord2iv), + SYM(MultiTexCoord2s), + SYM(MultiTexCoord2sv), + SYM(MultiTexCoord3d), + SYM(MultiTexCoord3dv), + SYM(MultiTexCoord3f), + SYM(MultiTexCoord3fv), + SYM(MultiTexCoord3i), + SYM(MultiTexCoord3iv), + SYM(MultiTexCoord3s), + SYM(MultiTexCoord3sv), + SYM(MultiTexCoord4d), + SYM(MultiTexCoord4dv), + SYM(MultiTexCoord4f), + SYM(MultiTexCoord4fv), + SYM(MultiTexCoord4i), + SYM(MultiTexCoord4iv), + SYM(MultiTexCoord4s), + SYM(MultiTexCoord4sv), + SYM(LoadTransposeMatrixd), + SYM(LoadTransposeMatrixf), + SYM(MultTransposeMatrixd), + SYM(MultTransposeMatrixf), + SYM(SampleCoverage), + SYM(ActiveTextureARB), + SYM(ClientActiveTextureARB), + SYM(MultiTexCoord1dARB), + SYM(MultiTexCoord1dvARB), + SYM(MultiTexCoord1fARB), + SYM(MultiTexCoord1fvARB), + SYM(MultiTexCoord1iARB), + SYM(MultiTexCoord1ivARB), + SYM(MultiTexCoord1sARB), + SYM(MultiTexCoord1svARB), + SYM(MultiTexCoord2dARB), + SYM(MultiTexCoord2dvARB), + SYM(MultiTexCoord2fARB), + SYM(MultiTexCoord2fvARB), + SYM(MultiTexCoord2iARB), + SYM(MultiTexCoord2ivARB), + SYM(MultiTexCoord2sARB), + SYM(MultiTexCoord2svARB), + SYM(MultiTexCoord3dARB), + SYM(MultiTexCoord3dvARB), + SYM(MultiTexCoord3fARB), + SYM(MultiTexCoord3fvARB), + SYM(MultiTexCoord3iARB), + SYM(MultiTexCoord3ivARB), + SYM(MultiTexCoord3sARB), + SYM(MultiTexCoord3svARB), + SYM(MultiTexCoord4dARB), + SYM(MultiTexCoord4dvARB), + SYM(MultiTexCoord4fARB), + SYM(MultiTexCoord4fvARB), + SYM(MultiTexCoord4iARB), + SYM(MultiTexCoord4ivARB), + SYM(MultiTexCoord4sARB), + SYM(MultiTexCoord4svARB), + SYM(EGLImageTargetTexture2DOES), + SYM(EGLImageTargetRenderbufferStorageOES), +#endif + + SYM(DrawRangeElements), + SYM(TexImage3D), + SYM(TexSubImage3D), + SYM(CopyTexSubImage3D), + SYM(ActiveTexture), + SYM(SampleCoverage), + SYM(CompressedTexImage3D), + SYM(CompressedTexImage2D), + SYM(CompressedTexImage1D), + SYM(CompressedTexSubImage3D), + SYM(CompressedTexSubImage2D), + SYM(CompressedTexSubImage1D), + SYM(GetCompressedTexImage), + SYM(ClientActiveTexture), + SYM(MultiTexCoord1d), + SYM(MultiTexCoord1dv), + SYM(MultiTexCoord1f), + SYM(MultiTexCoord1fv), + SYM(MultiTexCoord1i), + SYM(MultiTexCoord1iv), + SYM(MultiTexCoord1s), + SYM(MultiTexCoord1sv), + SYM(MultiTexCoord2d), + SYM(MultiTexCoord2dv), + SYM(MultiTexCoord2f), + SYM(MultiTexCoord2fv), + SYM(MultiTexCoord2i), + SYM(MultiTexCoord2iv), + SYM(MultiTexCoord2s), + SYM(MultiTexCoord2sv), + SYM(MultiTexCoord3d), + SYM(MultiTexCoord3dv), + SYM(MultiTexCoord3f), + SYM(MultiTexCoord3fv), + SYM(MultiTexCoord3i), + SYM(MultiTexCoord3iv), + SYM(MultiTexCoord3s), + SYM(MultiTexCoord3sv), + SYM(MultiTexCoord4d), + SYM(MultiTexCoord4dv), + SYM(MultiTexCoord4f), + SYM(MultiTexCoord4fv), + SYM(MultiTexCoord4i), + SYM(MultiTexCoord4iv), + SYM(MultiTexCoord4s), + SYM(MultiTexCoord4sv), + SYM(LoadTransposeMatrixf), + SYM(LoadTransposeMatrixd), + SYM(MultTransposeMatrixf), + SYM(MultTransposeMatrixd), + SYM(BlendFuncSeparate), + SYM(MultiDrawArrays), + SYM(MultiDrawElements), + SYM(PointParameterf), + SYM(PointParameterfv), + SYM(PointParameteri), + SYM(PointParameteriv), + SYM(FogCoordf), + SYM(FogCoordfv), + SYM(FogCoordd), + SYM(FogCoorddv), + SYM(FogCoordPointer), + SYM(SecondaryColor3b), + SYM(SecondaryColor3bv), + SYM(SecondaryColor3d), + SYM(SecondaryColor3dv), + SYM(SecondaryColor3f), + SYM(SecondaryColor3fv), + SYM(SecondaryColor3i), + SYM(SecondaryColor3iv), + SYM(SecondaryColor3s), + SYM(SecondaryColor3sv), + SYM(SecondaryColor3ub), + SYM(SecondaryColor3ubv), + SYM(SecondaryColor3ui), + SYM(SecondaryColor3uiv), + SYM(SecondaryColor3us), + SYM(SecondaryColor3usv), + SYM(SecondaryColorPointer), + SYM(WindowPos2d), + SYM(WindowPos2dv), + SYM(WindowPos2f), + SYM(WindowPos2fv), + SYM(WindowPos2i), + SYM(WindowPos2iv), + SYM(WindowPos2s), + SYM(WindowPos2sv), + SYM(WindowPos3d), + SYM(WindowPos3dv), + SYM(WindowPos3f), + SYM(WindowPos3fv), + SYM(WindowPos3i), + SYM(WindowPos3iv), + SYM(WindowPos3s), + SYM(WindowPos3sv), + SYM(BlendColor), + SYM(BlendEquation), + SYM(GenQueries), + SYM(DeleteQueries), + SYM(IsQuery), + SYM(BeginQuery), + SYM(EndQuery), + SYM(GetQueryiv), + SYM(GetQueryObjectiv), + SYM(GetQueryObjectuiv), + SYM(BindBuffer), + SYM(DeleteBuffers), + SYM(GenBuffers), + SYM(IsBuffer), + SYM(BufferData), + SYM(BufferSubData), + SYM(GetBufferSubData), + SYM(MapBuffer), + SYM(UnmapBuffer), + SYM(GetBufferParameteriv), + SYM(GetBufferPointerv), + SYM(BlendEquationSeparate), + SYM(DrawBuffers), + SYM(StencilOpSeparate), + SYM(StencilFuncSeparate), + SYM(StencilMaskSeparate), + SYM(AttachShader), + SYM(BindAttribLocation), + SYM(CompileShader), + SYM(CreateProgram), + SYM(CreateShader), + SYM(DeleteProgram), + SYM(DeleteShader), + SYM(DetachShader), + SYM(DisableVertexAttribArray), + SYM(EnableVertexAttribArray), + SYM(GetActiveAttrib), + SYM(GetActiveUniform), + SYM(GetAttachedShaders), + SYM(GetAttribLocation), + SYM(GetProgramiv), + SYM(GetProgramInfoLog), + SYM(GetShaderiv), + SYM(GetShaderInfoLog), + SYM(GetShaderSource), + SYM(GetUniformLocation), + SYM(GetUniformfv), + SYM(GetUniformiv), + SYM(GetVertexAttribdv), + SYM(GetVertexAttribfv), + SYM(GetVertexAttribiv), + SYM(GetVertexAttribPointerv), + SYM(IsProgram), + SYM(IsShader), + SYM(LinkProgram), + SYM(ShaderSource), + SYM(UseProgram), + SYM(Uniform1f), + SYM(Uniform2f), + SYM(Uniform3f), + SYM(Uniform4f), + SYM(Uniform1i), + SYM(Uniform2i), + SYM(Uniform3i), + SYM(Uniform4i), + SYM(Uniform1fv), + SYM(Uniform2fv), + SYM(Uniform3fv), + SYM(Uniform4fv), + SYM(Uniform1iv), + SYM(Uniform2iv), + SYM(Uniform3iv), + SYM(Uniform4iv), + SYM(UniformMatrix2fv), + SYM(UniformMatrix3fv), + SYM(UniformMatrix4fv), + SYM(ValidateProgram), + SYM(VertexAttrib1d), + SYM(VertexAttrib1dv), + SYM(VertexAttrib1f), + SYM(VertexAttrib1fv), + SYM(VertexAttrib1s), + SYM(VertexAttrib1sv), + SYM(VertexAttrib2d), + SYM(VertexAttrib2dv), + SYM(VertexAttrib2f), + SYM(VertexAttrib2fv), + SYM(VertexAttrib2s), + SYM(VertexAttrib2sv), + SYM(VertexAttrib3d), + SYM(VertexAttrib3dv), + SYM(VertexAttrib3f), + SYM(VertexAttrib3fv), + SYM(VertexAttrib3s), + SYM(VertexAttrib3sv), + SYM(VertexAttrib4Nbv), + SYM(VertexAttrib4Niv), + SYM(VertexAttrib4Nsv), + SYM(VertexAttrib4Nub), + SYM(VertexAttrib4Nubv), + SYM(VertexAttrib4Nuiv), + SYM(VertexAttrib4Nusv), + SYM(VertexAttrib4bv), + SYM(VertexAttrib4d), + SYM(VertexAttrib4dv), + SYM(VertexAttrib4f), + SYM(VertexAttrib4fv), + SYM(VertexAttrib4iv), + SYM(VertexAttrib4s), + SYM(VertexAttrib4sv), + SYM(VertexAttrib4ubv), + SYM(VertexAttrib4uiv), + SYM(VertexAttrib4usv), + SYM(VertexAttribPointer), + SYM(UniformMatrix2x3fv), + SYM(UniformMatrix3x2fv), + SYM(UniformMatrix2x4fv), + SYM(UniformMatrix4x2fv), + SYM(UniformMatrix3x4fv), + SYM(UniformMatrix4x3fv), + SYM(ColorMaski), + SYM(GetBooleani_v), + SYM(GetIntegeri_v), + SYM(Enablei), + SYM(Disablei), + SYM(IsEnabledi), + SYM(BeginTransformFeedback), + SYM(EndTransformFeedback), + SYM(BindBufferRange), + SYM(BindBufferBase), + SYM(TransformFeedbackVaryings), + SYM(GetTransformFeedbackVarying), + SYM(ClampColor), + SYM(BeginConditionalRender), + SYM(EndConditionalRender), + SYM(VertexAttribIPointer), + SYM(GetVertexAttribIiv), + SYM(GetVertexAttribIuiv), + SYM(VertexAttribI1i), + SYM(VertexAttribI2i), + SYM(VertexAttribI3i), + SYM(VertexAttribI4i), + SYM(VertexAttribI1ui), + SYM(VertexAttribI2ui), + SYM(VertexAttribI3ui), + SYM(VertexAttribI4ui), + SYM(VertexAttribI1iv), + SYM(VertexAttribI2iv), + SYM(VertexAttribI3iv), + SYM(VertexAttribI4iv), + SYM(VertexAttribI1uiv), + SYM(VertexAttribI2uiv), + SYM(VertexAttribI3uiv), + SYM(VertexAttribI4uiv), + SYM(VertexAttribI4bv), + SYM(VertexAttribI4sv), + SYM(VertexAttribI4ubv), + SYM(VertexAttribI4usv), + SYM(GetUniformuiv), + SYM(BindFragDataLocation), + SYM(GetFragDataLocation), + SYM(Uniform1ui), + SYM(Uniform2ui), + SYM(Uniform3ui), + SYM(Uniform4ui), + SYM(Uniform1uiv), + SYM(Uniform2uiv), + SYM(Uniform3uiv), + SYM(Uniform4uiv), + SYM(TexParameterIiv), + SYM(TexParameterIuiv), + SYM(GetTexParameterIiv), + SYM(GetTexParameterIuiv), + SYM(ClearBufferiv), + SYM(ClearBufferuiv), + SYM(ClearBufferfv), + SYM(ClearBufferfi), + SYM(GetStringi), + SYM(IsRenderbuffer), + SYM(BindRenderbuffer), + SYM(DeleteRenderbuffers), + SYM(GenRenderbuffers), + SYM(RenderbufferStorage), + SYM(GetRenderbufferParameteriv), + SYM(IsFramebuffer), + SYM(BindFramebuffer), + SYM(DeleteFramebuffers), + SYM(GenFramebuffers), + SYM(CheckFramebufferStatus), + SYM(FramebufferTexture1D), + SYM(FramebufferTexture2D), + SYM(FramebufferTexture3D), + SYM(FramebufferRenderbuffer), + SYM(GetFramebufferAttachmentParameteriv), + SYM(GenerateMipmap), + SYM(BlitFramebuffer), + SYM(RenderbufferStorageMultisample), + SYM(FramebufferTextureLayer), + SYM(MapBufferRange), + SYM(FlushMappedBufferRange), + SYM(BindVertexArray), + SYM(DeleteVertexArrays), + SYM(GenVertexArrays), + SYM(IsVertexArray), + SYM(DrawArraysInstanced), + SYM(DrawElementsInstanced), + SYM(TexBuffer), + SYM(PrimitiveRestartIndex), + SYM(CopyBufferSubData), + SYM(GetUniformIndices), + SYM(GetActiveUniformsiv), + SYM(GetActiveUniformName), + SYM(GetUniformBlockIndex), + SYM(GetActiveUniformBlockiv), + SYM(GetActiveUniformBlockName), + SYM(UniformBlockBinding), + SYM(DrawElementsBaseVertex), + SYM(DrawRangeElementsBaseVertex), + SYM(DrawElementsInstancedBaseVertex), + SYM(MultiDrawElementsBaseVertex), + SYM(ProvokingVertex), + SYM(FenceSync), + SYM(IsSync), + SYM(DeleteSync), + SYM(ClientWaitSync), + SYM(WaitSync), + SYM(GetInteger64v), + SYM(GetSynciv), + SYM(GetInteger64i_v), + SYM(GetBufferParameteri64v), + SYM(FramebufferTexture), + SYM(TexImage2DMultisample), + SYM(TexImage3DMultisample), + SYM(GetMultisamplefv), + SYM(SampleMaski), + SYM(BindFragDataLocationIndexed), + SYM(GetFragDataIndex), + SYM(GenSamplers), + SYM(DeleteSamplers), + SYM(IsSampler), + SYM(BindSampler), + SYM(SamplerParameteri), + SYM(SamplerParameteriv), + SYM(SamplerParameterf), + SYM(SamplerParameterfv), + SYM(SamplerParameterIiv), + SYM(SamplerParameterIuiv), + SYM(GetSamplerParameteriv), + SYM(GetSamplerParameterIiv), + SYM(GetSamplerParameterfv), + SYM(GetSamplerParameterIuiv), + SYM(QueryCounter), + SYM(GetQueryObjecti64v), + SYM(GetQueryObjectui64v), + SYM(VertexAttribDivisor), + SYM(VertexAttribP1ui), + SYM(VertexAttribP1uiv), + SYM(VertexAttribP2ui), + SYM(VertexAttribP2uiv), + SYM(VertexAttribP3ui), + SYM(VertexAttribP3uiv), + SYM(VertexAttribP4ui), + SYM(VertexAttribP4uiv), + SYM(VertexP2ui), + SYM(VertexP2uiv), + SYM(VertexP3ui), + SYM(VertexP3uiv), + SYM(VertexP4ui), + SYM(VertexP4uiv), + SYM(TexCoordP1ui), + SYM(TexCoordP1uiv), + SYM(TexCoordP2ui), + SYM(TexCoordP2uiv), + SYM(TexCoordP3ui), + SYM(TexCoordP3uiv), + SYM(TexCoordP4ui), + SYM(TexCoordP4uiv), + SYM(MultiTexCoordP1ui), + SYM(MultiTexCoordP1uiv), + SYM(MultiTexCoordP2ui), + SYM(MultiTexCoordP2uiv), + SYM(MultiTexCoordP3ui), + SYM(MultiTexCoordP3uiv), + SYM(MultiTexCoordP4ui), + SYM(MultiTexCoordP4uiv), + SYM(NormalP3ui), + SYM(NormalP3uiv), + SYM(ColorP3ui), + SYM(ColorP3uiv), + SYM(ColorP4ui), + SYM(ColorP4uiv), + SYM(SecondaryColorP3ui), + SYM(SecondaryColorP3uiv), + SYM(MinSampleShading), + SYM(BlendEquationi), + SYM(BlendEquationSeparatei), + SYM(BlendFunci), + SYM(BlendFuncSeparatei), + SYM(DrawArraysIndirect), + SYM(DrawElementsIndirect), + SYM(Uniform1d), + SYM(Uniform2d), + SYM(Uniform3d), + SYM(Uniform4d), + SYM(Uniform1dv), + SYM(Uniform2dv), + SYM(Uniform3dv), + SYM(Uniform4dv), + SYM(UniformMatrix2dv), + SYM(UniformMatrix3dv), + SYM(UniformMatrix4dv), + SYM(UniformMatrix2x3dv), + SYM(UniformMatrix2x4dv), + SYM(UniformMatrix3x2dv), + SYM(UniformMatrix3x4dv), + SYM(UniformMatrix4x2dv), + SYM(UniformMatrix4x3dv), + SYM(GetUniformdv), + SYM(GetSubroutineUniformLocation), + SYM(GetSubroutineIndex), + SYM(GetActiveSubroutineUniformiv), + SYM(GetActiveSubroutineUniformName), + SYM(GetActiveSubroutineName), + SYM(UniformSubroutinesuiv), + SYM(GetUniformSubroutineuiv), + SYM(GetProgramStageiv), + SYM(PatchParameteri), + SYM(PatchParameterfv), + SYM(BindTransformFeedback), + SYM(DeleteTransformFeedbacks), + SYM(GenTransformFeedbacks), + SYM(IsTransformFeedback), + SYM(PauseTransformFeedback), + SYM(ResumeTransformFeedback), + SYM(DrawTransformFeedback), + SYM(DrawTransformFeedbackStream), + SYM(BeginQueryIndexed), + SYM(EndQueryIndexed), + SYM(GetQueryIndexediv), + SYM(ReleaseShaderCompiler), + SYM(ShaderBinary), + SYM(GetShaderPrecisionFormat), + SYM(DepthRangef), + SYM(ClearDepthf), + SYM(GetProgramBinary), + SYM(ProgramBinary), + SYM(ProgramParameteri), + SYM(UseProgramStages), + SYM(ActiveShaderProgram), + SYM(CreateShaderProgramv), + SYM(BindProgramPipeline), + SYM(DeleteProgramPipelines), + SYM(GenProgramPipelines), + SYM(IsProgramPipeline), + SYM(GetProgramPipelineiv), + SYM(ProgramUniform1i), + SYM(ProgramUniform1iv), + SYM(ProgramUniform1f), + SYM(ProgramUniform1fv), + SYM(ProgramUniform1d), + SYM(ProgramUniform1dv), + SYM(ProgramUniform1ui), + SYM(ProgramUniform1uiv), + SYM(ProgramUniform2i), + SYM(ProgramUniform2iv), + SYM(ProgramUniform2f), + SYM(ProgramUniform2fv), + SYM(ProgramUniform2d), + SYM(ProgramUniform2dv), + SYM(ProgramUniform2ui), + SYM(ProgramUniform2uiv), + SYM(ProgramUniform3i), + SYM(ProgramUniform3iv), + SYM(ProgramUniform3f), + SYM(ProgramUniform3fv), + SYM(ProgramUniform3d), + SYM(ProgramUniform3dv), + SYM(ProgramUniform3ui), + SYM(ProgramUniform3uiv), + SYM(ProgramUniform4i), + SYM(ProgramUniform4iv), + SYM(ProgramUniform4f), + SYM(ProgramUniform4fv), + SYM(ProgramUniform4d), + SYM(ProgramUniform4dv), + SYM(ProgramUniform4ui), + SYM(ProgramUniform4uiv), + SYM(ProgramUniformMatrix2fv), + SYM(ProgramUniformMatrix3fv), + SYM(ProgramUniformMatrix4fv), + SYM(ProgramUniformMatrix2dv), + SYM(ProgramUniformMatrix3dv), + SYM(ProgramUniformMatrix4dv), + SYM(ProgramUniformMatrix2x3fv), + SYM(ProgramUniformMatrix3x2fv), + SYM(ProgramUniformMatrix2x4fv), + SYM(ProgramUniformMatrix4x2fv), + SYM(ProgramUniformMatrix3x4fv), + SYM(ProgramUniformMatrix4x3fv), + SYM(ProgramUniformMatrix2x3dv), + SYM(ProgramUniformMatrix3x2dv), + SYM(ProgramUniformMatrix2x4dv), + SYM(ProgramUniformMatrix4x2dv), + SYM(ProgramUniformMatrix3x4dv), + SYM(ProgramUniformMatrix4x3dv), + SYM(ValidateProgramPipeline), + SYM(GetProgramPipelineInfoLog), + SYM(VertexAttribL1d), + SYM(VertexAttribL2d), + SYM(VertexAttribL3d), + SYM(VertexAttribL4d), + SYM(VertexAttribL1dv), + SYM(VertexAttribL2dv), + SYM(VertexAttribL3dv), + SYM(VertexAttribL4dv), + SYM(VertexAttribLPointer), + SYM(GetVertexAttribLdv), + SYM(ViewportArrayv), + SYM(ViewportIndexedf), + SYM(ViewportIndexedfv), + SYM(ScissorArrayv), + SYM(ScissorIndexed), + SYM(ScissorIndexedv), + SYM(DepthRangeArrayv), + SYM(DepthRangeIndexed), + SYM(GetFloati_v), + SYM(GetDoublei_v), + SYM(DrawArraysInstancedBaseInstance), + SYM(DrawElementsInstancedBaseInstance), + SYM(DrawElementsInstancedBaseVertexBaseInstance), + SYM(GetInternalformativ), + SYM(GetActiveAtomicCounterBufferiv), + SYM(BindImageTexture), + SYM(MemoryBarrier), + SYM(TexStorage1D), + SYM(TexStorage2D), + SYM(TexStorage3D), + SYM(DrawTransformFeedbackInstanced), + SYM(DrawTransformFeedbackStreamInstanced), + SYM(ClearBufferData), + SYM(ClearBufferSubData), + SYM(DispatchCompute), + SYM(DispatchComputeIndirect), + SYM(CopyImageSubData), + SYM(FramebufferParameteri), + SYM(GetFramebufferParameteriv), + SYM(GetInternalformati64v), + SYM(InvalidateTexSubImage), + SYM(InvalidateTexImage), + SYM(InvalidateBufferSubData), + SYM(InvalidateBufferData), + SYM(InvalidateFramebuffer), + SYM(InvalidateSubFramebuffer), + SYM(MultiDrawArraysIndirect), + SYM(MultiDrawElementsIndirect), + SYM(GetProgramInterfaceiv), + SYM(GetProgramResourceIndex), + SYM(GetProgramResourceName), + SYM(GetProgramResourceiv), + SYM(GetProgramResourceLocation), + SYM(GetProgramResourceLocationIndex), + SYM(ShaderStorageBlockBinding), + SYM(TexBufferRange), + SYM(TexStorage2DMultisample), + SYM(TexStorage3DMultisample), + SYM(TextureView), + SYM(BindVertexBuffer), + SYM(VertexAttribFormat), + SYM(VertexAttribIFormat), + SYM(VertexAttribLFormat), + SYM(VertexAttribBinding), + SYM(VertexBindingDivisor), + SYM(DebugMessageControl), + SYM(DebugMessageInsert), + SYM(DebugMessageCallback), + SYM(GetDebugMessageLog), + SYM(PushDebugGroup), + SYM(PopDebugGroup), + SYM(ObjectLabel), + SYM(GetObjectLabel), + SYM(ObjectPtrLabel), + SYM(GetObjectPtrLabel), + SYM(BufferStorage), + SYM(ClearTexImage), + SYM(ClearTexSubImage), + SYM(BindBuffersBase), + SYM(BindBuffersRange), + SYM(BindTextures), + SYM(BindSamplers), + SYM(BindImageTextures), + SYM(BindVertexBuffers), + SYM(GetTextureHandleARB), + SYM(GetTextureSamplerHandleARB), + SYM(MakeTextureHandleResidentARB), + SYM(MakeTextureHandleNonResidentARB), + SYM(GetImageHandleARB), + SYM(MakeImageHandleResidentARB), + SYM(MakeImageHandleNonResidentARB), + SYM(UniformHandleui64ARB), + SYM(UniformHandleui64vARB), + SYM(ProgramUniformHandleui64ARB), + SYM(ProgramUniformHandleui64vARB), + SYM(IsTextureHandleResidentARB), + SYM(IsImageHandleResidentARB), + SYM(VertexAttribL1ui64ARB), + SYM(VertexAttribL1ui64vARB), + SYM(GetVertexAttribLui64vARB), + SYM(CreateSyncFromCLeventARB), + SYM(ClampColorARB), + SYM(DispatchComputeGroupSizeARB), + SYM(DebugMessageControlARB), + SYM(DebugMessageInsertARB), + SYM(DebugMessageCallbackARB), + SYM(GetDebugMessageLogARB), + SYM(DrawBuffersARB), + SYM(BlendEquationiARB), + SYM(BlendEquationSeparateiARB), + SYM(BlendFunciARB), + SYM(BlendFuncSeparateiARB), + SYM(DrawArraysInstancedARB), + SYM(DrawElementsInstancedARB), + SYM(ProgramStringARB), + SYM(BindProgramARB), + SYM(DeleteProgramsARB), + SYM(GenProgramsARB), + SYM(ProgramEnvParameter4dARB), + SYM(ProgramEnvParameter4dvARB), + SYM(ProgramEnvParameter4fARB), + SYM(ProgramEnvParameter4fvARB), + SYM(ProgramLocalParameter4dARB), + SYM(ProgramLocalParameter4dvARB), + SYM(ProgramLocalParameter4fARB), + SYM(ProgramLocalParameter4fvARB), + SYM(GetProgramEnvParameterdvARB), + SYM(GetProgramEnvParameterfvARB), + SYM(GetProgramLocalParameterdvARB), + SYM(GetProgramLocalParameterfvARB), + SYM(GetProgramivARB), + SYM(GetProgramStringARB), + SYM(IsProgramARB), + SYM(ProgramParameteriARB), + SYM(FramebufferTextureARB), + SYM(FramebufferTextureLayerARB), + SYM(FramebufferTextureFaceARB), + SYM(ColorTable), + SYM(ColorTableParameterfv), + SYM(ColorTableParameteriv), + SYM(CopyColorTable), + SYM(GetColorTable), + SYM(GetColorTableParameterfv), + SYM(GetColorTableParameteriv), + SYM(ColorSubTable), + SYM(CopyColorSubTable), + SYM(ConvolutionFilter1D), + SYM(ConvolutionFilter2D), + SYM(ConvolutionParameterf), + SYM(ConvolutionParameterfv), + SYM(ConvolutionParameteri), + SYM(ConvolutionParameteriv), + SYM(CopyConvolutionFilter1D), + SYM(CopyConvolutionFilter2D), + SYM(GetConvolutionFilter), + SYM(GetConvolutionParameterfv), + SYM(GetConvolutionParameteriv), + SYM(GetSeparableFilter), + SYM(SeparableFilter2D), + SYM(GetHistogram), + SYM(GetHistogramParameterfv), + SYM(GetHistogramParameteriv), + SYM(GetMinmax), + SYM(GetMinmaxParameterfv), + SYM(GetMinmaxParameteriv), + SYM(Histogram), + SYM(Minmax), + SYM(ResetHistogram), + SYM(ResetMinmax), + SYM(MultiDrawArraysIndirectCountARB), + SYM(MultiDrawElementsIndirectCountARB), + SYM(VertexAttribDivisorARB), + SYM(CurrentPaletteMatrixARB), + SYM(MatrixIndexubvARB), + SYM(MatrixIndexusvARB), + SYM(MatrixIndexuivARB), + SYM(MatrixIndexPointerARB), + SYM(SampleCoverageARB), + SYM(ActiveTextureARB), + SYM(ClientActiveTextureARB), + SYM(MultiTexCoord1dARB), + SYM(MultiTexCoord1dvARB), + SYM(MultiTexCoord1fARB), + SYM(MultiTexCoord1fvARB), + SYM(MultiTexCoord1iARB), + SYM(MultiTexCoord1ivARB), + SYM(MultiTexCoord1sARB), + SYM(MultiTexCoord1svARB), + SYM(MultiTexCoord2dARB), + SYM(MultiTexCoord2dvARB), + SYM(MultiTexCoord2fARB), + SYM(MultiTexCoord2fvARB), + SYM(MultiTexCoord2iARB), + SYM(MultiTexCoord2ivARB), + SYM(MultiTexCoord2sARB), + SYM(MultiTexCoord2svARB), + SYM(MultiTexCoord3dARB), + SYM(MultiTexCoord3dvARB), + SYM(MultiTexCoord3fARB), + SYM(MultiTexCoord3fvARB), + SYM(MultiTexCoord3iARB), + SYM(MultiTexCoord3ivARB), + SYM(MultiTexCoord3sARB), + SYM(MultiTexCoord3svARB), + SYM(MultiTexCoord4dARB), + SYM(MultiTexCoord4dvARB), + SYM(MultiTexCoord4fARB), + SYM(MultiTexCoord4fvARB), + SYM(MultiTexCoord4iARB), + SYM(MultiTexCoord4ivARB), + SYM(MultiTexCoord4sARB), + SYM(MultiTexCoord4svARB), + SYM(GenQueriesARB), + SYM(DeleteQueriesARB), + SYM(IsQueryARB), + SYM(BeginQueryARB), + SYM(EndQueryARB), + SYM(GetQueryivARB), + SYM(GetQueryObjectivARB), + SYM(GetQueryObjectuivARB), + SYM(PointParameterfARB), + SYM(PointParameterfvARB), + SYM(GetGraphicsResetStatusARB), + SYM(GetnTexImageARB), + SYM(ReadnPixelsARB), + SYM(GetnCompressedTexImageARB), + SYM(GetnUniformfvARB), + SYM(GetnUniformivARB), + SYM(GetnUniformuivARB), + SYM(GetnUniformdvARB), + SYM(GetnMapdvARB), + SYM(GetnMapfvARB), + SYM(GetnMapivARB), + SYM(GetnPixelMapfvARB), + SYM(GetnPixelMapuivARB), + SYM(GetnPixelMapusvARB), + SYM(GetnPolygonStippleARB), + SYM(GetnColorTableARB), + SYM(GetnConvolutionFilterARB), + SYM(GetnSeparableFilterARB), + SYM(GetnHistogramARB), + SYM(GetnMinmaxARB), + SYM(MinSampleShadingARB), + SYM(DeleteObjectARB), + SYM(GetHandleARB), + SYM(DetachObjectARB), + SYM(CreateShaderObjectARB), + SYM(ShaderSourceARB), + SYM(CompileShaderARB), + SYM(CreateProgramObjectARB), + SYM(AttachObjectARB), + SYM(LinkProgramARB), + SYM(UseProgramObjectARB), + SYM(ValidateProgramARB), + SYM(Uniform1fARB), + SYM(Uniform2fARB), + SYM(Uniform3fARB), + SYM(Uniform4fARB), + SYM(Uniform1iARB), + SYM(Uniform2iARB), + SYM(Uniform3iARB), + SYM(Uniform4iARB), + SYM(Uniform1fvARB), + SYM(Uniform2fvARB), + SYM(Uniform3fvARB), + SYM(Uniform4fvARB), + SYM(Uniform1ivARB), + SYM(Uniform2ivARB), + SYM(Uniform3ivARB), + SYM(Uniform4ivARB), + SYM(UniformMatrix2fvARB), + SYM(UniformMatrix3fvARB), + SYM(UniformMatrix4fvARB), + SYM(GetObjectParameterfvARB), + SYM(GetObjectParameterivARB), + SYM(GetInfoLogARB), + SYM(GetAttachedObjectsARB), + SYM(GetUniformLocationARB), + SYM(GetActiveUniformARB), + SYM(GetUniformfvARB), + SYM(GetUniformivARB), + SYM(GetShaderSourceARB), + SYM(NamedStringARB), + SYM(DeleteNamedStringARB), + SYM(CompileShaderIncludeARB), + SYM(IsNamedStringARB), + SYM(GetNamedStringARB), + SYM(GetNamedStringivARB), + SYM(TexPageCommitmentARB), + SYM(TexBufferARB), + SYM(CompressedTexImage3DARB), + SYM(CompressedTexImage2DARB), + SYM(CompressedTexImage1DARB), + SYM(CompressedTexSubImage3DARB), + SYM(CompressedTexSubImage2DARB), + SYM(CompressedTexSubImage1DARB), + SYM(GetCompressedTexImageARB), + SYM(LoadTransposeMatrixfARB), + SYM(LoadTransposeMatrixdARB), + SYM(MultTransposeMatrixfARB), + SYM(MultTransposeMatrixdARB), + SYM(WeightbvARB), + SYM(WeightsvARB), + SYM(WeightivARB), + SYM(WeightfvARB), + SYM(WeightdvARB), + SYM(WeightubvARB), + SYM(WeightusvARB), + SYM(WeightuivARB), + SYM(WeightPointerARB), + SYM(VertexBlendARB), + SYM(BindBufferARB), + SYM(DeleteBuffersARB), + SYM(GenBuffersARB), + SYM(IsBufferARB), + SYM(BufferDataARB), + SYM(BufferSubDataARB), + SYM(GetBufferSubDataARB), + SYM(MapBufferARB), + SYM(UnmapBufferARB), + SYM(GetBufferParameterivARB), + SYM(GetBufferPointervARB), + SYM(VertexAttrib1dARB), + SYM(VertexAttrib1dvARB), + SYM(VertexAttrib1fARB), + SYM(VertexAttrib1fvARB), + SYM(VertexAttrib1sARB), + SYM(VertexAttrib1svARB), + SYM(VertexAttrib2dARB), + SYM(VertexAttrib2dvARB), + SYM(VertexAttrib2fARB), + SYM(VertexAttrib2fvARB), + SYM(VertexAttrib2sARB), + SYM(VertexAttrib2svARB), + SYM(VertexAttrib3dARB), + SYM(VertexAttrib3dvARB), + SYM(VertexAttrib3fARB), + SYM(VertexAttrib3fvARB), + SYM(VertexAttrib3sARB), + SYM(VertexAttrib3svARB), + SYM(VertexAttrib4NbvARB), + SYM(VertexAttrib4NivARB), + SYM(VertexAttrib4NsvARB), + SYM(VertexAttrib4NubARB), + SYM(VertexAttrib4NubvARB), + SYM(VertexAttrib4NuivARB), + SYM(VertexAttrib4NusvARB), + SYM(VertexAttrib4bvARB), + SYM(VertexAttrib4dARB), + SYM(VertexAttrib4dvARB), + SYM(VertexAttrib4fARB), + SYM(VertexAttrib4fvARB), + SYM(VertexAttrib4ivARB), + SYM(VertexAttrib4sARB), + SYM(VertexAttrib4svARB), + SYM(VertexAttrib4ubvARB), + SYM(VertexAttrib4uivARB), + SYM(VertexAttrib4usvARB), + SYM(VertexAttribPointerARB), + SYM(EnableVertexAttribArrayARB), + SYM(DisableVertexAttribArrayARB), + SYM(GetVertexAttribdvARB), + SYM(GetVertexAttribfvARB), + SYM(GetVertexAttribivARB), + SYM(GetVertexAttribPointervARB), + SYM(BindAttribLocationARB), + SYM(GetActiveAttribARB), + SYM(GetAttribLocationARB), + SYM(WindowPos2dARB), + SYM(WindowPos2dvARB), + SYM(WindowPos2fARB), + SYM(WindowPos2fvARB), + SYM(WindowPos2iARB), + SYM(WindowPos2ivARB), + SYM(WindowPos2sARB), + SYM(WindowPos2svARB), + SYM(WindowPos3dARB), + SYM(WindowPos3dvARB), + SYM(WindowPos3fARB), + SYM(WindowPos3fvARB), + SYM(WindowPos3iARB), + SYM(WindowPos3ivARB), + SYM(WindowPos3sARB), + SYM(WindowPos3svARB), + SYM(MultiTexCoord1bOES), + SYM(MultiTexCoord1bvOES), + SYM(MultiTexCoord2bOES), + SYM(MultiTexCoord2bvOES), + SYM(MultiTexCoord3bOES), + SYM(MultiTexCoord3bvOES), + SYM(MultiTexCoord4bOES), + SYM(MultiTexCoord4bvOES), + SYM(TexCoord1bOES), + SYM(TexCoord1bvOES), + SYM(TexCoord2bOES), + SYM(TexCoord2bvOES), + SYM(TexCoord3bOES), + SYM(TexCoord3bvOES), + SYM(TexCoord4bOES), + SYM(TexCoord4bvOES), + SYM(Vertex2bOES), + SYM(Vertex2bvOES), + SYM(Vertex3bOES), + SYM(Vertex3bvOES), + SYM(Vertex4bOES), + SYM(Vertex4bvOES), + SYM(AlphaFuncxOES), + SYM(ClearColorxOES), + SYM(ClearDepthxOES), + SYM(ClipPlanexOES), + SYM(Color4xOES), + SYM(DepthRangexOES), + SYM(FogxOES), + SYM(FogxvOES), + SYM(FrustumxOES), + SYM(GetClipPlanexOES), + SYM(GetFixedvOES), + SYM(GetTexEnvxvOES), + SYM(GetTexParameterxvOES), + SYM(LightModelxOES), + SYM(LightModelxvOES), + SYM(LightxOES), + SYM(LightxvOES), + SYM(LineWidthxOES), + SYM(LoadMatrixxOES), + SYM(MaterialxOES), + SYM(MaterialxvOES), + SYM(MultMatrixxOES), + SYM(MultiTexCoord4xOES), + SYM(Normal3xOES), + SYM(OrthoxOES), + SYM(PointParameterxvOES), + SYM(PointSizexOES), + SYM(PolygonOffsetxOES), + SYM(RotatexOES), + SYM(SampleCoverageOES), + SYM(ScalexOES), + SYM(TexEnvxOES), + SYM(TexEnvxvOES), + SYM(TexParameterxOES), + SYM(TexParameterxvOES), + SYM(TranslatexOES), + SYM(AccumxOES), + SYM(BitmapxOES), + SYM(BlendColorxOES), + SYM(ClearAccumxOES), + SYM(Color3xOES), + SYM(Color3xvOES), + SYM(Color4xvOES), + SYM(ConvolutionParameterxOES), + SYM(ConvolutionParameterxvOES), + SYM(EvalCoord1xOES), + SYM(EvalCoord1xvOES), + SYM(EvalCoord2xOES), + SYM(EvalCoord2xvOES), + SYM(FeedbackBufferxOES), + SYM(GetConvolutionParameterxvOES), + SYM(GetHistogramParameterxvOES), + SYM(GetLightxOES), + SYM(GetMapxvOES), + SYM(GetMaterialxOES), + SYM(GetPixelMapxv), + SYM(GetTexGenxvOES), + SYM(GetTexLevelParameterxvOES), + SYM(IndexxOES), + SYM(IndexxvOES), + SYM(LoadTransposeMatrixxOES), + SYM(Map1xOES), + SYM(Map2xOES), + SYM(MapGrid1xOES), + SYM(MapGrid2xOES), + SYM(MultTransposeMatrixxOES), + SYM(MultiTexCoord1xOES), + SYM(MultiTexCoord1xvOES), + SYM(MultiTexCoord2xOES), + SYM(MultiTexCoord2xvOES), + SYM(MultiTexCoord3xOES), + SYM(MultiTexCoord3xvOES), + SYM(MultiTexCoord4xvOES), + SYM(Normal3xvOES), + SYM(PassThroughxOES), + SYM(PixelMapx), + SYM(PixelStorex), + SYM(PixelTransferxOES), + SYM(PixelZoomxOES), + SYM(PrioritizeTexturesxOES), + SYM(RasterPos2xOES), + SYM(RasterPos2xvOES), + SYM(RasterPos3xOES), + SYM(RasterPos3xvOES), + SYM(RasterPos4xOES), + SYM(RasterPos4xvOES), + SYM(RectxOES), + SYM(RectxvOES), + SYM(TexCoord1xOES), + SYM(TexCoord1xvOES), + SYM(TexCoord2xOES), + SYM(TexCoord2xvOES), + SYM(TexCoord3xOES), + SYM(TexCoord3xvOES), + SYM(TexCoord4xOES), + SYM(TexCoord4xvOES), + SYM(TexGenxOES), + SYM(TexGenxvOES), + SYM(Vertex2xOES), + SYM(Vertex2xvOES), + SYM(Vertex3xOES), + SYM(Vertex3xvOES), + SYM(Vertex4xOES), + SYM(Vertex4xvOES), + SYM(QueryMatrixxOES), + SYM(ClearDepthfOES), + SYM(ClipPlanefOES), + SYM(DepthRangefOES), + SYM(FrustumfOES), + SYM(GetClipPlanefOES), + SYM(OrthofOES), + SYM(ImageTransformParameteriHP), + SYM(ImageTransformParameterfHP), + SYM(ImageTransformParameterivHP), + SYM(ImageTransformParameterfvHP), + SYM(GetImageTransformParameterivHP), + SYM(GetImageTransformParameterfvHP), + + { NULL, NULL }, +}; +RGLSYMGLDRAWRANGEELEMENTSPROC __rglgen_glDrawRangeElements; +RGLSYMGLTEXIMAGE3DPROC __rglgen_glTexImage3D; +RGLSYMGLTEXSUBIMAGE3DPROC __rglgen_glTexSubImage3D; +RGLSYMGLCOPYTEXSUBIMAGE3DPROC __rglgen_glCopyTexSubImage3D; +RGLSYMGLACTIVETEXTUREPROC __rglgen_glActiveTexture; +RGLSYMGLSAMPLECOVERAGEPROC __rglgen_glSampleCoverage; +RGLSYMGLCOMPRESSEDTEXIMAGE3DPROC __rglgen_glCompressedTexImage3D; +RGLSYMGLCOMPRESSEDTEXIMAGE2DPROC __rglgen_glCompressedTexImage2D; +RGLSYMGLCOMPRESSEDTEXIMAGE1DPROC __rglgen_glCompressedTexImage1D; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE3DPROC __rglgen_glCompressedTexSubImage3D; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE2DPROC __rglgen_glCompressedTexSubImage2D; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE1DPROC __rglgen_glCompressedTexSubImage1D; +RGLSYMGLGETCOMPRESSEDTEXIMAGEPROC __rglgen_glGetCompressedTexImage; +RGLSYMGLCLIENTACTIVETEXTUREPROC __rglgen_glClientActiveTexture; +RGLSYMGLMULTITEXCOORD1DPROC __rglgen_glMultiTexCoord1d; +RGLSYMGLMULTITEXCOORD1DVPROC __rglgen_glMultiTexCoord1dv; +RGLSYMGLMULTITEXCOORD1FPROC __rglgen_glMultiTexCoord1f; +RGLSYMGLMULTITEXCOORD1FVPROC __rglgen_glMultiTexCoord1fv; +RGLSYMGLMULTITEXCOORD1IPROC __rglgen_glMultiTexCoord1i; +RGLSYMGLMULTITEXCOORD1IVPROC __rglgen_glMultiTexCoord1iv; +RGLSYMGLMULTITEXCOORD1SPROC __rglgen_glMultiTexCoord1s; +RGLSYMGLMULTITEXCOORD1SVPROC __rglgen_glMultiTexCoord1sv; +RGLSYMGLMULTITEXCOORD2DPROC __rglgen_glMultiTexCoord2d; +RGLSYMGLMULTITEXCOORD2DVPROC __rglgen_glMultiTexCoord2dv; +RGLSYMGLMULTITEXCOORD2FPROC __rglgen_glMultiTexCoord2f; +RGLSYMGLMULTITEXCOORD2FVPROC __rglgen_glMultiTexCoord2fv; +RGLSYMGLMULTITEXCOORD2IPROC __rglgen_glMultiTexCoord2i; +RGLSYMGLMULTITEXCOORD2IVPROC __rglgen_glMultiTexCoord2iv; +RGLSYMGLMULTITEXCOORD2SPROC __rglgen_glMultiTexCoord2s; +RGLSYMGLMULTITEXCOORD2SVPROC __rglgen_glMultiTexCoord2sv; +RGLSYMGLMULTITEXCOORD3DPROC __rglgen_glMultiTexCoord3d; +RGLSYMGLMULTITEXCOORD3DVPROC __rglgen_glMultiTexCoord3dv; +RGLSYMGLMULTITEXCOORD3FPROC __rglgen_glMultiTexCoord3f; +RGLSYMGLMULTITEXCOORD3FVPROC __rglgen_glMultiTexCoord3fv; +RGLSYMGLMULTITEXCOORD3IPROC __rglgen_glMultiTexCoord3i; +RGLSYMGLMULTITEXCOORD3IVPROC __rglgen_glMultiTexCoord3iv; +RGLSYMGLMULTITEXCOORD3SPROC __rglgen_glMultiTexCoord3s; +RGLSYMGLMULTITEXCOORD3SVPROC __rglgen_glMultiTexCoord3sv; +RGLSYMGLMULTITEXCOORD4DPROC __rglgen_glMultiTexCoord4d; +RGLSYMGLMULTITEXCOORD4DVPROC __rglgen_glMultiTexCoord4dv; +RGLSYMGLMULTITEXCOORD4FPROC __rglgen_glMultiTexCoord4f; +RGLSYMGLMULTITEXCOORD4FVPROC __rglgen_glMultiTexCoord4fv; +RGLSYMGLMULTITEXCOORD4IPROC __rglgen_glMultiTexCoord4i; +RGLSYMGLMULTITEXCOORD4IVPROC __rglgen_glMultiTexCoord4iv; +RGLSYMGLMULTITEXCOORD4SPROC __rglgen_glMultiTexCoord4s; +RGLSYMGLMULTITEXCOORD4SVPROC __rglgen_glMultiTexCoord4sv; +RGLSYMGLLOADTRANSPOSEMATRIXFPROC __rglgen_glLoadTransposeMatrixf; +RGLSYMGLLOADTRANSPOSEMATRIXDPROC __rglgen_glLoadTransposeMatrixd; +RGLSYMGLMULTTRANSPOSEMATRIXFPROC __rglgen_glMultTransposeMatrixf; +RGLSYMGLMULTTRANSPOSEMATRIXDPROC __rglgen_glMultTransposeMatrixd; +RGLSYMGLBLENDFUNCSEPARATEPROC __rglgen_glBlendFuncSeparate; +RGLSYMGLMULTIDRAWARRAYSPROC __rglgen_glMultiDrawArrays; +RGLSYMGLMULTIDRAWELEMENTSPROC __rglgen_glMultiDrawElements; +RGLSYMGLPOINTPARAMETERFPROC __rglgen_glPointParameterf; +RGLSYMGLPOINTPARAMETERFVPROC __rglgen_glPointParameterfv; +RGLSYMGLPOINTPARAMETERIPROC __rglgen_glPointParameteri; +RGLSYMGLPOINTPARAMETERIVPROC __rglgen_glPointParameteriv; +RGLSYMGLFOGCOORDFPROC __rglgen_glFogCoordf; +RGLSYMGLFOGCOORDFVPROC __rglgen_glFogCoordfv; +RGLSYMGLFOGCOORDDPROC __rglgen_glFogCoordd; +RGLSYMGLFOGCOORDDVPROC __rglgen_glFogCoorddv; +RGLSYMGLFOGCOORDPOINTERPROC __rglgen_glFogCoordPointer; +RGLSYMGLSECONDARYCOLOR3BPROC __rglgen_glSecondaryColor3b; +RGLSYMGLSECONDARYCOLOR3BVPROC __rglgen_glSecondaryColor3bv; +RGLSYMGLSECONDARYCOLOR3DPROC __rglgen_glSecondaryColor3d; +RGLSYMGLSECONDARYCOLOR3DVPROC __rglgen_glSecondaryColor3dv; +RGLSYMGLSECONDARYCOLOR3FPROC __rglgen_glSecondaryColor3f; +RGLSYMGLSECONDARYCOLOR3FVPROC __rglgen_glSecondaryColor3fv; +RGLSYMGLSECONDARYCOLOR3IPROC __rglgen_glSecondaryColor3i; +RGLSYMGLSECONDARYCOLOR3IVPROC __rglgen_glSecondaryColor3iv; +RGLSYMGLSECONDARYCOLOR3SPROC __rglgen_glSecondaryColor3s; +RGLSYMGLSECONDARYCOLOR3SVPROC __rglgen_glSecondaryColor3sv; +RGLSYMGLSECONDARYCOLOR3UBPROC __rglgen_glSecondaryColor3ub; +RGLSYMGLSECONDARYCOLOR3UBVPROC __rglgen_glSecondaryColor3ubv; +RGLSYMGLSECONDARYCOLOR3UIPROC __rglgen_glSecondaryColor3ui; +RGLSYMGLSECONDARYCOLOR3UIVPROC __rglgen_glSecondaryColor3uiv; +RGLSYMGLSECONDARYCOLOR3USPROC __rglgen_glSecondaryColor3us; +RGLSYMGLSECONDARYCOLOR3USVPROC __rglgen_glSecondaryColor3usv; +RGLSYMGLSECONDARYCOLORPOINTERPROC __rglgen_glSecondaryColorPointer; +RGLSYMGLWINDOWPOS2DPROC __rglgen_glWindowPos2d; +RGLSYMGLWINDOWPOS2DVPROC __rglgen_glWindowPos2dv; +RGLSYMGLWINDOWPOS2FPROC __rglgen_glWindowPos2f; +RGLSYMGLWINDOWPOS2FVPROC __rglgen_glWindowPos2fv; +RGLSYMGLWINDOWPOS2IPROC __rglgen_glWindowPos2i; +RGLSYMGLWINDOWPOS2IVPROC __rglgen_glWindowPos2iv; +RGLSYMGLWINDOWPOS2SPROC __rglgen_glWindowPos2s; +RGLSYMGLWINDOWPOS2SVPROC __rglgen_glWindowPos2sv; +RGLSYMGLWINDOWPOS3DPROC __rglgen_glWindowPos3d; +RGLSYMGLWINDOWPOS3DVPROC __rglgen_glWindowPos3dv; +RGLSYMGLWINDOWPOS3FPROC __rglgen_glWindowPos3f; +RGLSYMGLWINDOWPOS3FVPROC __rglgen_glWindowPos3fv; +RGLSYMGLWINDOWPOS3IPROC __rglgen_glWindowPos3i; +RGLSYMGLWINDOWPOS3IVPROC __rglgen_glWindowPos3iv; +RGLSYMGLWINDOWPOS3SPROC __rglgen_glWindowPos3s; +RGLSYMGLWINDOWPOS3SVPROC __rglgen_glWindowPos3sv; +RGLSYMGLBLENDCOLORPROC __rglgen_glBlendColor; +RGLSYMGLBLENDEQUATIONPROC __rglgen_glBlendEquation; +RGLSYMGLGENQUERIESPROC __rglgen_glGenQueries; +RGLSYMGLDELETEQUERIESPROC __rglgen_glDeleteQueries; +RGLSYMGLISQUERYPROC __rglgen_glIsQuery; +RGLSYMGLBEGINQUERYPROC __rglgen_glBeginQuery; +RGLSYMGLENDQUERYPROC __rglgen_glEndQuery; +RGLSYMGLGETQUERYIVPROC __rglgen_glGetQueryiv; +RGLSYMGLGETQUERYOBJECTIVPROC __rglgen_glGetQueryObjectiv; +RGLSYMGLGETQUERYOBJECTUIVPROC __rglgen_glGetQueryObjectuiv; +RGLSYMGLBINDBUFFERPROC __rglgen_glBindBuffer; +RGLSYMGLDELETEBUFFERSPROC __rglgen_glDeleteBuffers; +RGLSYMGLGENBUFFERSPROC __rglgen_glGenBuffers; +RGLSYMGLISBUFFERPROC __rglgen_glIsBuffer; +RGLSYMGLBUFFERDATAPROC __rglgen_glBufferData; +RGLSYMGLBUFFERSUBDATAPROC __rglgen_glBufferSubData; +RGLSYMGLGETBUFFERSUBDATAPROC __rglgen_glGetBufferSubData; +RGLSYMGLMAPBUFFERPROC __rglgen_glMapBuffer; +RGLSYMGLUNMAPBUFFERPROC __rglgen_glUnmapBuffer; +RGLSYMGLGETBUFFERPARAMETERIVPROC __rglgen_glGetBufferParameteriv; +RGLSYMGLGETBUFFERPOINTERVPROC __rglgen_glGetBufferPointerv; +RGLSYMGLBLENDEQUATIONSEPARATEPROC __rglgen_glBlendEquationSeparate; +RGLSYMGLDRAWBUFFERSPROC __rglgen_glDrawBuffers; +RGLSYMGLSTENCILOPSEPARATEPROC __rglgen_glStencilOpSeparate; +RGLSYMGLSTENCILFUNCSEPARATEPROC __rglgen_glStencilFuncSeparate; +RGLSYMGLSTENCILMASKSEPARATEPROC __rglgen_glStencilMaskSeparate; +RGLSYMGLATTACHSHADERPROC __rglgen_glAttachShader; +RGLSYMGLBINDATTRIBLOCATIONPROC __rglgen_glBindAttribLocation; +RGLSYMGLCOMPILESHADERPROC __rglgen_glCompileShader; +RGLSYMGLCREATEPROGRAMPROC __rglgen_glCreateProgram; +RGLSYMGLCREATESHADERPROC __rglgen_glCreateShader; +RGLSYMGLDELETEPROGRAMPROC __rglgen_glDeleteProgram; +RGLSYMGLDELETESHADERPROC __rglgen_glDeleteShader; +RGLSYMGLDETACHSHADERPROC __rglgen_glDetachShader; +RGLSYMGLDISABLEVERTEXATTRIBARRAYPROC __rglgen_glDisableVertexAttribArray; +RGLSYMGLENABLEVERTEXATTRIBARRAYPROC __rglgen_glEnableVertexAttribArray; +RGLSYMGLGETACTIVEATTRIBPROC __rglgen_glGetActiveAttrib; +RGLSYMGLGETACTIVEUNIFORMPROC __rglgen_glGetActiveUniform; +RGLSYMGLGETATTACHEDSHADERSPROC __rglgen_glGetAttachedShaders; +RGLSYMGLGETATTRIBLOCATIONPROC __rglgen_glGetAttribLocation; +RGLSYMGLGETPROGRAMIVPROC __rglgen_glGetProgramiv; +RGLSYMGLGETPROGRAMINFOLOGPROC __rglgen_glGetProgramInfoLog; +RGLSYMGLGETSHADERIVPROC __rglgen_glGetShaderiv; +RGLSYMGLGETSHADERINFOLOGPROC __rglgen_glGetShaderInfoLog; +RGLSYMGLGETSHADERSOURCEPROC __rglgen_glGetShaderSource; +RGLSYMGLGETUNIFORMLOCATIONPROC __rglgen_glGetUniformLocation; +RGLSYMGLGETUNIFORMFVPROC __rglgen_glGetUniformfv; +RGLSYMGLGETUNIFORMIVPROC __rglgen_glGetUniformiv; +RGLSYMGLGETVERTEXATTRIBDVPROC __rglgen_glGetVertexAttribdv; +RGLSYMGLGETVERTEXATTRIBFVPROC __rglgen_glGetVertexAttribfv; +RGLSYMGLGETVERTEXATTRIBIVPROC __rglgen_glGetVertexAttribiv; +RGLSYMGLGETVERTEXATTRIBPOINTERVPROC __rglgen_glGetVertexAttribPointerv; +RGLSYMGLISPROGRAMPROC __rglgen_glIsProgram; +RGLSYMGLISSHADERPROC __rglgen_glIsShader; +RGLSYMGLLINKPROGRAMPROC __rglgen_glLinkProgram; +RGLSYMGLSHADERSOURCEPROC __rglgen_glShaderSource; +RGLSYMGLUSEPROGRAMPROC __rglgen_glUseProgram; +RGLSYMGLUNIFORM1FPROC __rglgen_glUniform1f; +RGLSYMGLUNIFORM2FPROC __rglgen_glUniform2f; +RGLSYMGLUNIFORM3FPROC __rglgen_glUniform3f; +RGLSYMGLUNIFORM4FPROC __rglgen_glUniform4f; +RGLSYMGLUNIFORM1IPROC __rglgen_glUniform1i; +RGLSYMGLUNIFORM2IPROC __rglgen_glUniform2i; +RGLSYMGLUNIFORM3IPROC __rglgen_glUniform3i; +RGLSYMGLUNIFORM4IPROC __rglgen_glUniform4i; +RGLSYMGLUNIFORM1FVPROC __rglgen_glUniform1fv; +RGLSYMGLUNIFORM2FVPROC __rglgen_glUniform2fv; +RGLSYMGLUNIFORM3FVPROC __rglgen_glUniform3fv; +RGLSYMGLUNIFORM4FVPROC __rglgen_glUniform4fv; +RGLSYMGLUNIFORM1IVPROC __rglgen_glUniform1iv; +RGLSYMGLUNIFORM2IVPROC __rglgen_glUniform2iv; +RGLSYMGLUNIFORM3IVPROC __rglgen_glUniform3iv; +RGLSYMGLUNIFORM4IVPROC __rglgen_glUniform4iv; +RGLSYMGLUNIFORMMATRIX2FVPROC __rglgen_glUniformMatrix2fv; +RGLSYMGLUNIFORMMATRIX3FVPROC __rglgen_glUniformMatrix3fv; +RGLSYMGLUNIFORMMATRIX4FVPROC __rglgen_glUniformMatrix4fv; +RGLSYMGLVALIDATEPROGRAMPROC __rglgen_glValidateProgram; +RGLSYMGLVERTEXATTRIB1DPROC __rglgen_glVertexAttrib1d; +RGLSYMGLVERTEXATTRIB1DVPROC __rglgen_glVertexAttrib1dv; +RGLSYMGLVERTEXATTRIB1FPROC __rglgen_glVertexAttrib1f; +RGLSYMGLVERTEXATTRIB1FVPROC __rglgen_glVertexAttrib1fv; +RGLSYMGLVERTEXATTRIB1SPROC __rglgen_glVertexAttrib1s; +RGLSYMGLVERTEXATTRIB1SVPROC __rglgen_glVertexAttrib1sv; +RGLSYMGLVERTEXATTRIB2DPROC __rglgen_glVertexAttrib2d; +RGLSYMGLVERTEXATTRIB2DVPROC __rglgen_glVertexAttrib2dv; +RGLSYMGLVERTEXATTRIB2FPROC __rglgen_glVertexAttrib2f; +RGLSYMGLVERTEXATTRIB2FVPROC __rglgen_glVertexAttrib2fv; +RGLSYMGLVERTEXATTRIB2SPROC __rglgen_glVertexAttrib2s; +RGLSYMGLVERTEXATTRIB2SVPROC __rglgen_glVertexAttrib2sv; +RGLSYMGLVERTEXATTRIB3DPROC __rglgen_glVertexAttrib3d; +RGLSYMGLVERTEXATTRIB3DVPROC __rglgen_glVertexAttrib3dv; +RGLSYMGLVERTEXATTRIB3FPROC __rglgen_glVertexAttrib3f; +RGLSYMGLVERTEXATTRIB3FVPROC __rglgen_glVertexAttrib3fv; +RGLSYMGLVERTEXATTRIB3SPROC __rglgen_glVertexAttrib3s; +RGLSYMGLVERTEXATTRIB3SVPROC __rglgen_glVertexAttrib3sv; +RGLSYMGLVERTEXATTRIB4NBVPROC __rglgen_glVertexAttrib4Nbv; +RGLSYMGLVERTEXATTRIB4NIVPROC __rglgen_glVertexAttrib4Niv; +RGLSYMGLVERTEXATTRIB4NSVPROC __rglgen_glVertexAttrib4Nsv; +RGLSYMGLVERTEXATTRIB4NUBPROC __rglgen_glVertexAttrib4Nub; +RGLSYMGLVERTEXATTRIB4NUBVPROC __rglgen_glVertexAttrib4Nubv; +RGLSYMGLVERTEXATTRIB4NUIVPROC __rglgen_glVertexAttrib4Nuiv; +RGLSYMGLVERTEXATTRIB4NUSVPROC __rglgen_glVertexAttrib4Nusv; +RGLSYMGLVERTEXATTRIB4BVPROC __rglgen_glVertexAttrib4bv; +RGLSYMGLVERTEXATTRIB4DPROC __rglgen_glVertexAttrib4d; +RGLSYMGLVERTEXATTRIB4DVPROC __rglgen_glVertexAttrib4dv; +RGLSYMGLVERTEXATTRIB4FPROC __rglgen_glVertexAttrib4f; +RGLSYMGLVERTEXATTRIB4FVPROC __rglgen_glVertexAttrib4fv; +RGLSYMGLVERTEXATTRIB4IVPROC __rglgen_glVertexAttrib4iv; +RGLSYMGLVERTEXATTRIB4SPROC __rglgen_glVertexAttrib4s; +RGLSYMGLVERTEXATTRIB4SVPROC __rglgen_glVertexAttrib4sv; +RGLSYMGLVERTEXATTRIB4UBVPROC __rglgen_glVertexAttrib4ubv; +RGLSYMGLVERTEXATTRIB4UIVPROC __rglgen_glVertexAttrib4uiv; +RGLSYMGLVERTEXATTRIB4USVPROC __rglgen_glVertexAttrib4usv; +RGLSYMGLVERTEXATTRIBPOINTERPROC __rglgen_glVertexAttribPointer; +RGLSYMGLUNIFORMMATRIX2X3FVPROC __rglgen_glUniformMatrix2x3fv; +RGLSYMGLUNIFORMMATRIX3X2FVPROC __rglgen_glUniformMatrix3x2fv; +RGLSYMGLUNIFORMMATRIX2X4FVPROC __rglgen_glUniformMatrix2x4fv; +RGLSYMGLUNIFORMMATRIX4X2FVPROC __rglgen_glUniformMatrix4x2fv; +RGLSYMGLUNIFORMMATRIX3X4FVPROC __rglgen_glUniformMatrix3x4fv; +RGLSYMGLUNIFORMMATRIX4X3FVPROC __rglgen_glUniformMatrix4x3fv; +RGLSYMGLCOLORMASKIPROC __rglgen_glColorMaski; +RGLSYMGLGETBOOLEANI_VPROC __rglgen_glGetBooleani_v; +RGLSYMGLGETINTEGERI_VPROC __rglgen_glGetIntegeri_v; +RGLSYMGLENABLEIPROC __rglgen_glEnablei; +RGLSYMGLDISABLEIPROC __rglgen_glDisablei; +RGLSYMGLISENABLEDIPROC __rglgen_glIsEnabledi; +RGLSYMGLBEGINTRANSFORMFEEDBACKPROC __rglgen_glBeginTransformFeedback; +RGLSYMGLENDTRANSFORMFEEDBACKPROC __rglgen_glEndTransformFeedback; +RGLSYMGLBINDBUFFERRANGEPROC __rglgen_glBindBufferRange; +RGLSYMGLBINDBUFFERBASEPROC __rglgen_glBindBufferBase; +RGLSYMGLTRANSFORMFEEDBACKVARYINGSPROC __rglgen_glTransformFeedbackVaryings; +RGLSYMGLGETTRANSFORMFEEDBACKVARYINGPROC __rglgen_glGetTransformFeedbackVarying; +RGLSYMGLCLAMPCOLORPROC __rglgen_glClampColor; +RGLSYMGLBEGINCONDITIONALRENDERPROC __rglgen_glBeginConditionalRender; +RGLSYMGLENDCONDITIONALRENDERPROC __rglgen_glEndConditionalRender; +RGLSYMGLVERTEXATTRIBIPOINTERPROC __rglgen_glVertexAttribIPointer; +RGLSYMGLGETVERTEXATTRIBIIVPROC __rglgen_glGetVertexAttribIiv; +RGLSYMGLGETVERTEXATTRIBIUIVPROC __rglgen_glGetVertexAttribIuiv; +RGLSYMGLVERTEXATTRIBI1IPROC __rglgen_glVertexAttribI1i; +RGLSYMGLVERTEXATTRIBI2IPROC __rglgen_glVertexAttribI2i; +RGLSYMGLVERTEXATTRIBI3IPROC __rglgen_glVertexAttribI3i; +RGLSYMGLVERTEXATTRIBI4IPROC __rglgen_glVertexAttribI4i; +RGLSYMGLVERTEXATTRIBI1UIPROC __rglgen_glVertexAttribI1ui; +RGLSYMGLVERTEXATTRIBI2UIPROC __rglgen_glVertexAttribI2ui; +RGLSYMGLVERTEXATTRIBI3UIPROC __rglgen_glVertexAttribI3ui; +RGLSYMGLVERTEXATTRIBI4UIPROC __rglgen_glVertexAttribI4ui; +RGLSYMGLVERTEXATTRIBI1IVPROC __rglgen_glVertexAttribI1iv; +RGLSYMGLVERTEXATTRIBI2IVPROC __rglgen_glVertexAttribI2iv; +RGLSYMGLVERTEXATTRIBI3IVPROC __rglgen_glVertexAttribI3iv; +RGLSYMGLVERTEXATTRIBI4IVPROC __rglgen_glVertexAttribI4iv; +RGLSYMGLVERTEXATTRIBI1UIVPROC __rglgen_glVertexAttribI1uiv; +RGLSYMGLVERTEXATTRIBI2UIVPROC __rglgen_glVertexAttribI2uiv; +RGLSYMGLVERTEXATTRIBI3UIVPROC __rglgen_glVertexAttribI3uiv; +RGLSYMGLVERTEXATTRIBI4UIVPROC __rglgen_glVertexAttribI4uiv; +RGLSYMGLVERTEXATTRIBI4BVPROC __rglgen_glVertexAttribI4bv; +RGLSYMGLVERTEXATTRIBI4SVPROC __rglgen_glVertexAttribI4sv; +RGLSYMGLVERTEXATTRIBI4UBVPROC __rglgen_glVertexAttribI4ubv; +RGLSYMGLVERTEXATTRIBI4USVPROC __rglgen_glVertexAttribI4usv; +RGLSYMGLGETUNIFORMUIVPROC __rglgen_glGetUniformuiv; +RGLSYMGLBINDFRAGDATALOCATIONPROC __rglgen_glBindFragDataLocation; +RGLSYMGLGETFRAGDATALOCATIONPROC __rglgen_glGetFragDataLocation; +RGLSYMGLUNIFORM1UIPROC __rglgen_glUniform1ui; +RGLSYMGLUNIFORM2UIPROC __rglgen_glUniform2ui; +RGLSYMGLUNIFORM3UIPROC __rglgen_glUniform3ui; +RGLSYMGLUNIFORM4UIPROC __rglgen_glUniform4ui; +RGLSYMGLUNIFORM1UIVPROC __rglgen_glUniform1uiv; +RGLSYMGLUNIFORM2UIVPROC __rglgen_glUniform2uiv; +RGLSYMGLUNIFORM3UIVPROC __rglgen_glUniform3uiv; +RGLSYMGLUNIFORM4UIVPROC __rglgen_glUniform4uiv; +RGLSYMGLTEXPARAMETERIIVPROC __rglgen_glTexParameterIiv; +RGLSYMGLTEXPARAMETERIUIVPROC __rglgen_glTexParameterIuiv; +RGLSYMGLGETTEXPARAMETERIIVPROC __rglgen_glGetTexParameterIiv; +RGLSYMGLGETTEXPARAMETERIUIVPROC __rglgen_glGetTexParameterIuiv; +RGLSYMGLCLEARBUFFERIVPROC __rglgen_glClearBufferiv; +RGLSYMGLCLEARBUFFERUIVPROC __rglgen_glClearBufferuiv; +RGLSYMGLCLEARBUFFERFVPROC __rglgen_glClearBufferfv; +RGLSYMGLCLEARBUFFERFIPROC __rglgen_glClearBufferfi; +RGLSYMGLGETSTRINGIPROC __rglgen_glGetStringi; +RGLSYMGLISRENDERBUFFERPROC __rglgen_glIsRenderbuffer; +RGLSYMGLBINDRENDERBUFFERPROC __rglgen_glBindRenderbuffer; +RGLSYMGLDELETERENDERBUFFERSPROC __rglgen_glDeleteRenderbuffers; +RGLSYMGLGENRENDERBUFFERSPROC __rglgen_glGenRenderbuffers; +RGLSYMGLRENDERBUFFERSTORAGEPROC __rglgen_glRenderbufferStorage; +RGLSYMGLGETRENDERBUFFERPARAMETERIVPROC __rglgen_glGetRenderbufferParameteriv; +RGLSYMGLISFRAMEBUFFERPROC __rglgen_glIsFramebuffer; +RGLSYMGLBINDFRAMEBUFFERPROC __rglgen_glBindFramebuffer; +RGLSYMGLDELETEFRAMEBUFFERSPROC __rglgen_glDeleteFramebuffers; +RGLSYMGLGENFRAMEBUFFERSPROC __rglgen_glGenFramebuffers; +RGLSYMGLCHECKFRAMEBUFFERSTATUSPROC __rglgen_glCheckFramebufferStatus; +RGLSYMGLFRAMEBUFFERTEXTURE1DPROC __rglgen_glFramebufferTexture1D; +RGLSYMGLFRAMEBUFFERTEXTURE2DPROC __rglgen_glFramebufferTexture2D; +RGLSYMGLFRAMEBUFFERTEXTURE3DPROC __rglgen_glFramebufferTexture3D; +RGLSYMGLFRAMEBUFFERRENDERBUFFERPROC __rglgen_glFramebufferRenderbuffer; +RGLSYMGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __rglgen_glGetFramebufferAttachmentParameteriv; +RGLSYMGLGENERATEMIPMAPPROC __rglgen_glGenerateMipmap; +RGLSYMGLBLITFRAMEBUFFERPROC __rglgen_glBlitFramebuffer; +RGLSYMGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __rglgen_glRenderbufferStorageMultisample; +RGLSYMGLFRAMEBUFFERTEXTURELAYERPROC __rglgen_glFramebufferTextureLayer; +RGLSYMGLMAPBUFFERRANGEPROC __rglgen_glMapBufferRange; +RGLSYMGLFLUSHMAPPEDBUFFERRANGEPROC __rglgen_glFlushMappedBufferRange; +RGLSYMGLBINDVERTEXARRAYPROC __rglgen_glBindVertexArray; +RGLSYMGLDELETEVERTEXARRAYSPROC __rglgen_glDeleteVertexArrays; +RGLSYMGLGENVERTEXARRAYSPROC __rglgen_glGenVertexArrays; +RGLSYMGLISVERTEXARRAYPROC __rglgen_glIsVertexArray; +RGLSYMGLDRAWARRAYSINSTANCEDPROC __rglgen_glDrawArraysInstanced; +RGLSYMGLDRAWELEMENTSINSTANCEDPROC __rglgen_glDrawElementsInstanced; +RGLSYMGLTEXBUFFERPROC __rglgen_glTexBuffer; +RGLSYMGLPRIMITIVERESTARTINDEXPROC __rglgen_glPrimitiveRestartIndex; +RGLSYMGLCOPYBUFFERSUBDATAPROC __rglgen_glCopyBufferSubData; +RGLSYMGLGETUNIFORMINDICESPROC __rglgen_glGetUniformIndices; +RGLSYMGLGETACTIVEUNIFORMSIVPROC __rglgen_glGetActiveUniformsiv; +RGLSYMGLGETACTIVEUNIFORMNAMEPROC __rglgen_glGetActiveUniformName; +RGLSYMGLGETUNIFORMBLOCKINDEXPROC __rglgen_glGetUniformBlockIndex; +RGLSYMGLGETACTIVEUNIFORMBLOCKIVPROC __rglgen_glGetActiveUniformBlockiv; +RGLSYMGLGETACTIVEUNIFORMBLOCKNAMEPROC __rglgen_glGetActiveUniformBlockName; +RGLSYMGLUNIFORMBLOCKBINDINGPROC __rglgen_glUniformBlockBinding; +RGLSYMGLDRAWELEMENTSBASEVERTEXPROC __rglgen_glDrawElementsBaseVertex; +RGLSYMGLDRAWRANGEELEMENTSBASEVERTEXPROC __rglgen_glDrawRangeElementsBaseVertex; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __rglgen_glDrawElementsInstancedBaseVertex; +RGLSYMGLMULTIDRAWELEMENTSBASEVERTEXPROC __rglgen_glMultiDrawElementsBaseVertex; +RGLSYMGLPROVOKINGVERTEXPROC __rglgen_glProvokingVertex; +RGLSYMGLFENCESYNCPROC __rglgen_glFenceSync; +RGLSYMGLISSYNCPROC __rglgen_glIsSync; +RGLSYMGLDELETESYNCPROC __rglgen_glDeleteSync; +RGLSYMGLCLIENTWAITSYNCPROC __rglgen_glClientWaitSync; +RGLSYMGLWAITSYNCPROC __rglgen_glWaitSync; +RGLSYMGLGETINTEGER64VPROC __rglgen_glGetInteger64v; +RGLSYMGLGETSYNCIVPROC __rglgen_glGetSynciv; +RGLSYMGLGETINTEGER64I_VPROC __rglgen_glGetInteger64i_v; +RGLSYMGLGETBUFFERPARAMETERI64VPROC __rglgen_glGetBufferParameteri64v; +RGLSYMGLFRAMEBUFFERTEXTUREPROC __rglgen_glFramebufferTexture; +RGLSYMGLTEXIMAGE2DMULTISAMPLEPROC __rglgen_glTexImage2DMultisample; +RGLSYMGLTEXIMAGE3DMULTISAMPLEPROC __rglgen_glTexImage3DMultisample; +RGLSYMGLGETMULTISAMPLEFVPROC __rglgen_glGetMultisamplefv; +RGLSYMGLSAMPLEMASKIPROC __rglgen_glSampleMaski; +RGLSYMGLBINDFRAGDATALOCATIONINDEXEDPROC __rglgen_glBindFragDataLocationIndexed; +RGLSYMGLGETFRAGDATAINDEXPROC __rglgen_glGetFragDataIndex; +RGLSYMGLGENSAMPLERSPROC __rglgen_glGenSamplers; +RGLSYMGLDELETESAMPLERSPROC __rglgen_glDeleteSamplers; +RGLSYMGLISSAMPLERPROC __rglgen_glIsSampler; +RGLSYMGLBINDSAMPLERPROC __rglgen_glBindSampler; +RGLSYMGLSAMPLERPARAMETERIPROC __rglgen_glSamplerParameteri; +RGLSYMGLSAMPLERPARAMETERIVPROC __rglgen_glSamplerParameteriv; +RGLSYMGLSAMPLERPARAMETERFPROC __rglgen_glSamplerParameterf; +RGLSYMGLSAMPLERPARAMETERFVPROC __rglgen_glSamplerParameterfv; +RGLSYMGLSAMPLERPARAMETERIIVPROC __rglgen_glSamplerParameterIiv; +RGLSYMGLSAMPLERPARAMETERIUIVPROC __rglgen_glSamplerParameterIuiv; +RGLSYMGLGETSAMPLERPARAMETERIVPROC __rglgen_glGetSamplerParameteriv; +RGLSYMGLGETSAMPLERPARAMETERIIVPROC __rglgen_glGetSamplerParameterIiv; +RGLSYMGLGETSAMPLERPARAMETERFVPROC __rglgen_glGetSamplerParameterfv; +RGLSYMGLGETSAMPLERPARAMETERIUIVPROC __rglgen_glGetSamplerParameterIuiv; +RGLSYMGLQUERYCOUNTERPROC __rglgen_glQueryCounter; +RGLSYMGLGETQUERYOBJECTI64VPROC __rglgen_glGetQueryObjecti64v; +RGLSYMGLGETQUERYOBJECTUI64VPROC __rglgen_glGetQueryObjectui64v; +RGLSYMGLVERTEXATTRIBDIVISORPROC __rglgen_glVertexAttribDivisor; +RGLSYMGLVERTEXATTRIBP1UIPROC __rglgen_glVertexAttribP1ui; +RGLSYMGLVERTEXATTRIBP1UIVPROC __rglgen_glVertexAttribP1uiv; +RGLSYMGLVERTEXATTRIBP2UIPROC __rglgen_glVertexAttribP2ui; +RGLSYMGLVERTEXATTRIBP2UIVPROC __rglgen_glVertexAttribP2uiv; +RGLSYMGLVERTEXATTRIBP3UIPROC __rglgen_glVertexAttribP3ui; +RGLSYMGLVERTEXATTRIBP3UIVPROC __rglgen_glVertexAttribP3uiv; +RGLSYMGLVERTEXATTRIBP4UIPROC __rglgen_glVertexAttribP4ui; +RGLSYMGLVERTEXATTRIBP4UIVPROC __rglgen_glVertexAttribP4uiv; +RGLSYMGLVERTEXP2UIPROC __rglgen_glVertexP2ui; +RGLSYMGLVERTEXP2UIVPROC __rglgen_glVertexP2uiv; +RGLSYMGLVERTEXP3UIPROC __rglgen_glVertexP3ui; +RGLSYMGLVERTEXP3UIVPROC __rglgen_glVertexP3uiv; +RGLSYMGLVERTEXP4UIPROC __rglgen_glVertexP4ui; +RGLSYMGLVERTEXP4UIVPROC __rglgen_glVertexP4uiv; +RGLSYMGLTEXCOORDP1UIPROC __rglgen_glTexCoordP1ui; +RGLSYMGLTEXCOORDP1UIVPROC __rglgen_glTexCoordP1uiv; +RGLSYMGLTEXCOORDP2UIPROC __rglgen_glTexCoordP2ui; +RGLSYMGLTEXCOORDP2UIVPROC __rglgen_glTexCoordP2uiv; +RGLSYMGLTEXCOORDP3UIPROC __rglgen_glTexCoordP3ui; +RGLSYMGLTEXCOORDP3UIVPROC __rglgen_glTexCoordP3uiv; +RGLSYMGLTEXCOORDP4UIPROC __rglgen_glTexCoordP4ui; +RGLSYMGLTEXCOORDP4UIVPROC __rglgen_glTexCoordP4uiv; +RGLSYMGLMULTITEXCOORDP1UIPROC __rglgen_glMultiTexCoordP1ui; +RGLSYMGLMULTITEXCOORDP1UIVPROC __rglgen_glMultiTexCoordP1uiv; +RGLSYMGLMULTITEXCOORDP2UIPROC __rglgen_glMultiTexCoordP2ui; +RGLSYMGLMULTITEXCOORDP2UIVPROC __rglgen_glMultiTexCoordP2uiv; +RGLSYMGLMULTITEXCOORDP3UIPROC __rglgen_glMultiTexCoordP3ui; +RGLSYMGLMULTITEXCOORDP3UIVPROC __rglgen_glMultiTexCoordP3uiv; +RGLSYMGLMULTITEXCOORDP4UIPROC __rglgen_glMultiTexCoordP4ui; +RGLSYMGLMULTITEXCOORDP4UIVPROC __rglgen_glMultiTexCoordP4uiv; +RGLSYMGLNORMALP3UIPROC __rglgen_glNormalP3ui; +RGLSYMGLNORMALP3UIVPROC __rglgen_glNormalP3uiv; +RGLSYMGLCOLORP3UIPROC __rglgen_glColorP3ui; +RGLSYMGLCOLORP3UIVPROC __rglgen_glColorP3uiv; +RGLSYMGLCOLORP4UIPROC __rglgen_glColorP4ui; +RGLSYMGLCOLORP4UIVPROC __rglgen_glColorP4uiv; +RGLSYMGLSECONDARYCOLORP3UIPROC __rglgen_glSecondaryColorP3ui; +RGLSYMGLSECONDARYCOLORP3UIVPROC __rglgen_glSecondaryColorP3uiv; +RGLSYMGLMINSAMPLESHADINGPROC __rglgen_glMinSampleShading; +RGLSYMGLBLENDEQUATIONIPROC __rglgen_glBlendEquationi; +RGLSYMGLBLENDEQUATIONSEPARATEIPROC __rglgen_glBlendEquationSeparatei; +RGLSYMGLBLENDFUNCIPROC __rglgen_glBlendFunci; +RGLSYMGLBLENDFUNCSEPARATEIPROC __rglgen_glBlendFuncSeparatei; +RGLSYMGLDRAWARRAYSINDIRECTPROC __rglgen_glDrawArraysIndirect; +RGLSYMGLDRAWELEMENTSINDIRECTPROC __rglgen_glDrawElementsIndirect; +RGLSYMGLUNIFORM1DPROC __rglgen_glUniform1d; +RGLSYMGLUNIFORM2DPROC __rglgen_glUniform2d; +RGLSYMGLUNIFORM3DPROC __rglgen_glUniform3d; +RGLSYMGLUNIFORM4DPROC __rglgen_glUniform4d; +RGLSYMGLUNIFORM1DVPROC __rglgen_glUniform1dv; +RGLSYMGLUNIFORM2DVPROC __rglgen_glUniform2dv; +RGLSYMGLUNIFORM3DVPROC __rglgen_glUniform3dv; +RGLSYMGLUNIFORM4DVPROC __rglgen_glUniform4dv; +RGLSYMGLUNIFORMMATRIX2DVPROC __rglgen_glUniformMatrix2dv; +RGLSYMGLUNIFORMMATRIX3DVPROC __rglgen_glUniformMatrix3dv; +RGLSYMGLUNIFORMMATRIX4DVPROC __rglgen_glUniformMatrix4dv; +RGLSYMGLUNIFORMMATRIX2X3DVPROC __rglgen_glUniformMatrix2x3dv; +RGLSYMGLUNIFORMMATRIX2X4DVPROC __rglgen_glUniformMatrix2x4dv; +RGLSYMGLUNIFORMMATRIX3X2DVPROC __rglgen_glUniformMatrix3x2dv; +RGLSYMGLUNIFORMMATRIX3X4DVPROC __rglgen_glUniformMatrix3x4dv; +RGLSYMGLUNIFORMMATRIX4X2DVPROC __rglgen_glUniformMatrix4x2dv; +RGLSYMGLUNIFORMMATRIX4X3DVPROC __rglgen_glUniformMatrix4x3dv; +RGLSYMGLGETUNIFORMDVPROC __rglgen_glGetUniformdv; +RGLSYMGLGETSUBROUTINEUNIFORMLOCATIONPROC __rglgen_glGetSubroutineUniformLocation; +RGLSYMGLGETSUBROUTINEINDEXPROC __rglgen_glGetSubroutineIndex; +RGLSYMGLGETACTIVESUBROUTINEUNIFORMIVPROC __rglgen_glGetActiveSubroutineUniformiv; +RGLSYMGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __rglgen_glGetActiveSubroutineUniformName; +RGLSYMGLGETACTIVESUBROUTINENAMEPROC __rglgen_glGetActiveSubroutineName; +RGLSYMGLUNIFORMSUBROUTINESUIVPROC __rglgen_glUniformSubroutinesuiv; +RGLSYMGLGETUNIFORMSUBROUTINEUIVPROC __rglgen_glGetUniformSubroutineuiv; +RGLSYMGLGETPROGRAMSTAGEIVPROC __rglgen_glGetProgramStageiv; +RGLSYMGLPATCHPARAMETERIPROC __rglgen_glPatchParameteri; +RGLSYMGLPATCHPARAMETERFVPROC __rglgen_glPatchParameterfv; +RGLSYMGLBINDTRANSFORMFEEDBACKPROC __rglgen_glBindTransformFeedback; +RGLSYMGLDELETETRANSFORMFEEDBACKSPROC __rglgen_glDeleteTransformFeedbacks; +RGLSYMGLGENTRANSFORMFEEDBACKSPROC __rglgen_glGenTransformFeedbacks; +RGLSYMGLISTRANSFORMFEEDBACKPROC __rglgen_glIsTransformFeedback; +RGLSYMGLPAUSETRANSFORMFEEDBACKPROC __rglgen_glPauseTransformFeedback; +RGLSYMGLRESUMETRANSFORMFEEDBACKPROC __rglgen_glResumeTransformFeedback; +RGLSYMGLDRAWTRANSFORMFEEDBACKPROC __rglgen_glDrawTransformFeedback; +RGLSYMGLDRAWTRANSFORMFEEDBACKSTREAMPROC __rglgen_glDrawTransformFeedbackStream; +RGLSYMGLBEGINQUERYINDEXEDPROC __rglgen_glBeginQueryIndexed; +RGLSYMGLENDQUERYINDEXEDPROC __rglgen_glEndQueryIndexed; +RGLSYMGLGETQUERYINDEXEDIVPROC __rglgen_glGetQueryIndexediv; +RGLSYMGLRELEASESHADERCOMPILERPROC __rglgen_glReleaseShaderCompiler; +RGLSYMGLSHADERBINARYPROC __rglgen_glShaderBinary; +RGLSYMGLGETSHADERPRECISIONFORMATPROC __rglgen_glGetShaderPrecisionFormat; +RGLSYMGLDEPTHRANGEFPROC __rglgen_glDepthRangef; +RGLSYMGLCLEARDEPTHFPROC __rglgen_glClearDepthf; +RGLSYMGLGETPROGRAMBINARYPROC __rglgen_glGetProgramBinary; +RGLSYMGLPROGRAMBINARYPROC __rglgen_glProgramBinary; +RGLSYMGLPROGRAMPARAMETERIPROC __rglgen_glProgramParameteri; +RGLSYMGLUSEPROGRAMSTAGESPROC __rglgen_glUseProgramStages; +RGLSYMGLACTIVESHADERPROGRAMPROC __rglgen_glActiveShaderProgram; +RGLSYMGLCREATESHADERPROGRAMVPROC __rglgen_glCreateShaderProgramv; +RGLSYMGLBINDPROGRAMPIPELINEPROC __rglgen_glBindProgramPipeline; +RGLSYMGLDELETEPROGRAMPIPELINESPROC __rglgen_glDeleteProgramPipelines; +RGLSYMGLGENPROGRAMPIPELINESPROC __rglgen_glGenProgramPipelines; +RGLSYMGLISPROGRAMPIPELINEPROC __rglgen_glIsProgramPipeline; +RGLSYMGLGETPROGRAMPIPELINEIVPROC __rglgen_glGetProgramPipelineiv; +RGLSYMGLPROGRAMUNIFORM1IPROC __rglgen_glProgramUniform1i; +RGLSYMGLPROGRAMUNIFORM1IVPROC __rglgen_glProgramUniform1iv; +RGLSYMGLPROGRAMUNIFORM1FPROC __rglgen_glProgramUniform1f; +RGLSYMGLPROGRAMUNIFORM1FVPROC __rglgen_glProgramUniform1fv; +RGLSYMGLPROGRAMUNIFORM1DPROC __rglgen_glProgramUniform1d; +RGLSYMGLPROGRAMUNIFORM1DVPROC __rglgen_glProgramUniform1dv; +RGLSYMGLPROGRAMUNIFORM1UIPROC __rglgen_glProgramUniform1ui; +RGLSYMGLPROGRAMUNIFORM1UIVPROC __rglgen_glProgramUniform1uiv; +RGLSYMGLPROGRAMUNIFORM2IPROC __rglgen_glProgramUniform2i; +RGLSYMGLPROGRAMUNIFORM2IVPROC __rglgen_glProgramUniform2iv; +RGLSYMGLPROGRAMUNIFORM2FPROC __rglgen_glProgramUniform2f; +RGLSYMGLPROGRAMUNIFORM2FVPROC __rglgen_glProgramUniform2fv; +RGLSYMGLPROGRAMUNIFORM2DPROC __rglgen_glProgramUniform2d; +RGLSYMGLPROGRAMUNIFORM2DVPROC __rglgen_glProgramUniform2dv; +RGLSYMGLPROGRAMUNIFORM2UIPROC __rglgen_glProgramUniform2ui; +RGLSYMGLPROGRAMUNIFORM2UIVPROC __rglgen_glProgramUniform2uiv; +RGLSYMGLPROGRAMUNIFORM3IPROC __rglgen_glProgramUniform3i; +RGLSYMGLPROGRAMUNIFORM3IVPROC __rglgen_glProgramUniform3iv; +RGLSYMGLPROGRAMUNIFORM3FPROC __rglgen_glProgramUniform3f; +RGLSYMGLPROGRAMUNIFORM3FVPROC __rglgen_glProgramUniform3fv; +RGLSYMGLPROGRAMUNIFORM3DPROC __rglgen_glProgramUniform3d; +RGLSYMGLPROGRAMUNIFORM3DVPROC __rglgen_glProgramUniform3dv; +RGLSYMGLPROGRAMUNIFORM3UIPROC __rglgen_glProgramUniform3ui; +RGLSYMGLPROGRAMUNIFORM3UIVPROC __rglgen_glProgramUniform3uiv; +RGLSYMGLPROGRAMUNIFORM4IPROC __rglgen_glProgramUniform4i; +RGLSYMGLPROGRAMUNIFORM4IVPROC __rglgen_glProgramUniform4iv; +RGLSYMGLPROGRAMUNIFORM4FPROC __rglgen_glProgramUniform4f; +RGLSYMGLPROGRAMUNIFORM4FVPROC __rglgen_glProgramUniform4fv; +RGLSYMGLPROGRAMUNIFORM4DPROC __rglgen_glProgramUniform4d; +RGLSYMGLPROGRAMUNIFORM4DVPROC __rglgen_glProgramUniform4dv; +RGLSYMGLPROGRAMUNIFORM4UIPROC __rglgen_glProgramUniform4ui; +RGLSYMGLPROGRAMUNIFORM4UIVPROC __rglgen_glProgramUniform4uiv; +RGLSYMGLPROGRAMUNIFORMMATRIX2FVPROC __rglgen_glProgramUniformMatrix2fv; +RGLSYMGLPROGRAMUNIFORMMATRIX3FVPROC __rglgen_glProgramUniformMatrix3fv; +RGLSYMGLPROGRAMUNIFORMMATRIX4FVPROC __rglgen_glProgramUniformMatrix4fv; +RGLSYMGLPROGRAMUNIFORMMATRIX2DVPROC __rglgen_glProgramUniformMatrix2dv; +RGLSYMGLPROGRAMUNIFORMMATRIX3DVPROC __rglgen_glProgramUniformMatrix3dv; +RGLSYMGLPROGRAMUNIFORMMATRIX4DVPROC __rglgen_glProgramUniformMatrix4dv; +RGLSYMGLPROGRAMUNIFORMMATRIX2X3FVPROC __rglgen_glProgramUniformMatrix2x3fv; +RGLSYMGLPROGRAMUNIFORMMATRIX3X2FVPROC __rglgen_glProgramUniformMatrix3x2fv; +RGLSYMGLPROGRAMUNIFORMMATRIX2X4FVPROC __rglgen_glProgramUniformMatrix2x4fv; +RGLSYMGLPROGRAMUNIFORMMATRIX4X2FVPROC __rglgen_glProgramUniformMatrix4x2fv; +RGLSYMGLPROGRAMUNIFORMMATRIX3X4FVPROC __rglgen_glProgramUniformMatrix3x4fv; +RGLSYMGLPROGRAMUNIFORMMATRIX4X3FVPROC __rglgen_glProgramUniformMatrix4x3fv; +RGLSYMGLPROGRAMUNIFORMMATRIX2X3DVPROC __rglgen_glProgramUniformMatrix2x3dv; +RGLSYMGLPROGRAMUNIFORMMATRIX3X2DVPROC __rglgen_glProgramUniformMatrix3x2dv; +RGLSYMGLPROGRAMUNIFORMMATRIX2X4DVPROC __rglgen_glProgramUniformMatrix2x4dv; +RGLSYMGLPROGRAMUNIFORMMATRIX4X2DVPROC __rglgen_glProgramUniformMatrix4x2dv; +RGLSYMGLPROGRAMUNIFORMMATRIX3X4DVPROC __rglgen_glProgramUniformMatrix3x4dv; +RGLSYMGLPROGRAMUNIFORMMATRIX4X3DVPROC __rglgen_glProgramUniformMatrix4x3dv; +RGLSYMGLVALIDATEPROGRAMPIPELINEPROC __rglgen_glValidateProgramPipeline; +RGLSYMGLGETPROGRAMPIPELINEINFOLOGPROC __rglgen_glGetProgramPipelineInfoLog; +RGLSYMGLVERTEXATTRIBL1DPROC __rglgen_glVertexAttribL1d; +RGLSYMGLVERTEXATTRIBL2DPROC __rglgen_glVertexAttribL2d; +RGLSYMGLVERTEXATTRIBL3DPROC __rglgen_glVertexAttribL3d; +RGLSYMGLVERTEXATTRIBL4DPROC __rglgen_glVertexAttribL4d; +RGLSYMGLVERTEXATTRIBL1DVPROC __rglgen_glVertexAttribL1dv; +RGLSYMGLVERTEXATTRIBL2DVPROC __rglgen_glVertexAttribL2dv; +RGLSYMGLVERTEXATTRIBL3DVPROC __rglgen_glVertexAttribL3dv; +RGLSYMGLVERTEXATTRIBL4DVPROC __rglgen_glVertexAttribL4dv; +RGLSYMGLVERTEXATTRIBLPOINTERPROC __rglgen_glVertexAttribLPointer; +RGLSYMGLGETVERTEXATTRIBLDVPROC __rglgen_glGetVertexAttribLdv; +RGLSYMGLVIEWPORTARRAYVPROC __rglgen_glViewportArrayv; +RGLSYMGLVIEWPORTINDEXEDFPROC __rglgen_glViewportIndexedf; +RGLSYMGLVIEWPORTINDEXEDFVPROC __rglgen_glViewportIndexedfv; +RGLSYMGLSCISSORARRAYVPROC __rglgen_glScissorArrayv; +RGLSYMGLSCISSORINDEXEDPROC __rglgen_glScissorIndexed; +RGLSYMGLSCISSORINDEXEDVPROC __rglgen_glScissorIndexedv; +RGLSYMGLDEPTHRANGEARRAYVPROC __rglgen_glDepthRangeArrayv; +RGLSYMGLDEPTHRANGEINDEXEDPROC __rglgen_glDepthRangeIndexed; +RGLSYMGLGETFLOATI_VPROC __rglgen_glGetFloati_v; +RGLSYMGLGETDOUBLEI_VPROC __rglgen_glGetDoublei_v; +RGLSYMGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __rglgen_glDrawArraysInstancedBaseInstance; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __rglgen_glDrawElementsInstancedBaseInstance; +RGLSYMGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __rglgen_glDrawElementsInstancedBaseVertexBaseInstance; +RGLSYMGLGETINTERNALFORMATIVPROC __rglgen_glGetInternalformativ; +RGLSYMGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __rglgen_glGetActiveAtomicCounterBufferiv; +RGLSYMGLBINDIMAGETEXTUREPROC __rglgen_glBindImageTexture; +RGLSYMGLMEMORYBARRIERPROC __rglgen_glMemoryBarrier; +RGLSYMGLTEXSTORAGE1DPROC __rglgen_glTexStorage1D; +RGLSYMGLTEXSTORAGE2DPROC __rglgen_glTexStorage2D; +RGLSYMGLTEXSTORAGE3DPROC __rglgen_glTexStorage3D; +RGLSYMGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __rglgen_glDrawTransformFeedbackInstanced; +RGLSYMGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __rglgen_glDrawTransformFeedbackStreamInstanced; +RGLSYMGLCLEARBUFFERDATAPROC __rglgen_glClearBufferData; +RGLSYMGLCLEARBUFFERSUBDATAPROC __rglgen_glClearBufferSubData; +RGLSYMGLDISPATCHCOMPUTEPROC __rglgen_glDispatchCompute; +RGLSYMGLDISPATCHCOMPUTEINDIRECTPROC __rglgen_glDispatchComputeIndirect; +RGLSYMGLCOPYIMAGESUBDATAPROC __rglgen_glCopyImageSubData; +RGLSYMGLFRAMEBUFFERPARAMETERIPROC __rglgen_glFramebufferParameteri; +RGLSYMGLGETFRAMEBUFFERPARAMETERIVPROC __rglgen_glGetFramebufferParameteriv; +RGLSYMGLGETINTERNALFORMATI64VPROC __rglgen_glGetInternalformati64v; +RGLSYMGLINVALIDATETEXSUBIMAGEPROC __rglgen_glInvalidateTexSubImage; +RGLSYMGLINVALIDATETEXIMAGEPROC __rglgen_glInvalidateTexImage; +RGLSYMGLINVALIDATEBUFFERSUBDATAPROC __rglgen_glInvalidateBufferSubData; +RGLSYMGLINVALIDATEBUFFERDATAPROC __rglgen_glInvalidateBufferData; +RGLSYMGLINVALIDATEFRAMEBUFFERPROC __rglgen_glInvalidateFramebuffer; +RGLSYMGLINVALIDATESUBFRAMEBUFFERPROC __rglgen_glInvalidateSubFramebuffer; +RGLSYMGLMULTIDRAWARRAYSINDIRECTPROC __rglgen_glMultiDrawArraysIndirect; +RGLSYMGLMULTIDRAWELEMENTSINDIRECTPROC __rglgen_glMultiDrawElementsIndirect; +RGLSYMGLGETPROGRAMINTERFACEIVPROC __rglgen_glGetProgramInterfaceiv; +RGLSYMGLGETPROGRAMRESOURCEINDEXPROC __rglgen_glGetProgramResourceIndex; +RGLSYMGLGETPROGRAMRESOURCENAMEPROC __rglgen_glGetProgramResourceName; +RGLSYMGLGETPROGRAMRESOURCEIVPROC __rglgen_glGetProgramResourceiv; +RGLSYMGLGETPROGRAMRESOURCELOCATIONPROC __rglgen_glGetProgramResourceLocation; +RGLSYMGLGETPROGRAMRESOURCELOCATIONINDEXPROC __rglgen_glGetProgramResourceLocationIndex; +RGLSYMGLSHADERSTORAGEBLOCKBINDINGPROC __rglgen_glShaderStorageBlockBinding; +RGLSYMGLTEXBUFFERRANGEPROC __rglgen_glTexBufferRange; +RGLSYMGLTEXSTORAGE2DMULTISAMPLEPROC __rglgen_glTexStorage2DMultisample; +RGLSYMGLTEXSTORAGE3DMULTISAMPLEPROC __rglgen_glTexStorage3DMultisample; +RGLSYMGLTEXTUREVIEWPROC __rglgen_glTextureView; +RGLSYMGLBINDVERTEXBUFFERPROC __rglgen_glBindVertexBuffer; +RGLSYMGLVERTEXATTRIBFORMATPROC __rglgen_glVertexAttribFormat; +RGLSYMGLVERTEXATTRIBIFORMATPROC __rglgen_glVertexAttribIFormat; +RGLSYMGLVERTEXATTRIBLFORMATPROC __rglgen_glVertexAttribLFormat; +RGLSYMGLVERTEXATTRIBBINDINGPROC __rglgen_glVertexAttribBinding; +RGLSYMGLVERTEXBINDINGDIVISORPROC __rglgen_glVertexBindingDivisor; +RGLSYMGLDEBUGMESSAGECONTROLPROC __rglgen_glDebugMessageControl; +RGLSYMGLDEBUGMESSAGEINSERTPROC __rglgen_glDebugMessageInsert; +RGLSYMGLDEBUGMESSAGECALLBACKPROC __rglgen_glDebugMessageCallback; +RGLSYMGLGETDEBUGMESSAGELOGPROC __rglgen_glGetDebugMessageLog; +RGLSYMGLPUSHDEBUGGROUPPROC __rglgen_glPushDebugGroup; +RGLSYMGLPOPDEBUGGROUPPROC __rglgen_glPopDebugGroup; +RGLSYMGLOBJECTLABELPROC __rglgen_glObjectLabel; +RGLSYMGLGETOBJECTLABELPROC __rglgen_glGetObjectLabel; +RGLSYMGLOBJECTPTRLABELPROC __rglgen_glObjectPtrLabel; +RGLSYMGLGETOBJECTPTRLABELPROC __rglgen_glGetObjectPtrLabel; +RGLSYMGLBUFFERSTORAGEPROC __rglgen_glBufferStorage; +RGLSYMGLCLEARTEXIMAGEPROC __rglgen_glClearTexImage; +RGLSYMGLCLEARTEXSUBIMAGEPROC __rglgen_glClearTexSubImage; +RGLSYMGLBINDBUFFERSBASEPROC __rglgen_glBindBuffersBase; +RGLSYMGLBINDBUFFERSRANGEPROC __rglgen_glBindBuffersRange; +RGLSYMGLBINDTEXTURESPROC __rglgen_glBindTextures; +RGLSYMGLBINDSAMPLERSPROC __rglgen_glBindSamplers; +RGLSYMGLBINDIMAGETEXTURESPROC __rglgen_glBindImageTextures; +RGLSYMGLBINDVERTEXBUFFERSPROC __rglgen_glBindVertexBuffers; +RGLSYMGLGETTEXTUREHANDLEARBPROC __rglgen_glGetTextureHandleARB; +RGLSYMGLGETTEXTURESAMPLERHANDLEARBPROC __rglgen_glGetTextureSamplerHandleARB; +RGLSYMGLMAKETEXTUREHANDLERESIDENTARBPROC __rglgen_glMakeTextureHandleResidentARB; +RGLSYMGLMAKETEXTUREHANDLENONRESIDENTARBPROC __rglgen_glMakeTextureHandleNonResidentARB; +RGLSYMGLGETIMAGEHANDLEARBPROC __rglgen_glGetImageHandleARB; +RGLSYMGLMAKEIMAGEHANDLERESIDENTARBPROC __rglgen_glMakeImageHandleResidentARB; +RGLSYMGLMAKEIMAGEHANDLENONRESIDENTARBPROC __rglgen_glMakeImageHandleNonResidentARB; +RGLSYMGLUNIFORMHANDLEUI64ARBPROC __rglgen_glUniformHandleui64ARB; +RGLSYMGLUNIFORMHANDLEUI64VARBPROC __rglgen_glUniformHandleui64vARB; +RGLSYMGLPROGRAMUNIFORMHANDLEUI64ARBPROC __rglgen_glProgramUniformHandleui64ARB; +RGLSYMGLPROGRAMUNIFORMHANDLEUI64VARBPROC __rglgen_glProgramUniformHandleui64vARB; +RGLSYMGLISTEXTUREHANDLERESIDENTARBPROC __rglgen_glIsTextureHandleResidentARB; +RGLSYMGLISIMAGEHANDLERESIDENTARBPROC __rglgen_glIsImageHandleResidentARB; +RGLSYMGLVERTEXATTRIBL1UI64ARBPROC __rglgen_glVertexAttribL1ui64ARB; +RGLSYMGLVERTEXATTRIBL1UI64VARBPROC __rglgen_glVertexAttribL1ui64vARB; +RGLSYMGLGETVERTEXATTRIBLUI64VARBPROC __rglgen_glGetVertexAttribLui64vARB; +RGLSYMGLCREATESYNCFROMCLEVENTARBPROC __rglgen_glCreateSyncFromCLeventARB; +RGLSYMGLCLAMPCOLORARBPROC __rglgen_glClampColorARB; +RGLSYMGLDISPATCHCOMPUTEGROUPSIZEARBPROC __rglgen_glDispatchComputeGroupSizeARB; +RGLSYMGLDEBUGMESSAGECONTROLARBPROC __rglgen_glDebugMessageControlARB; +RGLSYMGLDEBUGMESSAGEINSERTARBPROC __rglgen_glDebugMessageInsertARB; +RGLSYMGLDEBUGMESSAGECALLBACKARBPROC __rglgen_glDebugMessageCallbackARB; +RGLSYMGLGETDEBUGMESSAGELOGARBPROC __rglgen_glGetDebugMessageLogARB; +RGLSYMGLDRAWBUFFERSARBPROC __rglgen_glDrawBuffersARB; +RGLSYMGLBLENDEQUATIONIARBPROC __rglgen_glBlendEquationiARB; +RGLSYMGLBLENDEQUATIONSEPARATEIARBPROC __rglgen_glBlendEquationSeparateiARB; +RGLSYMGLBLENDFUNCIARBPROC __rglgen_glBlendFunciARB; +RGLSYMGLBLENDFUNCSEPARATEIARBPROC __rglgen_glBlendFuncSeparateiARB; +RGLSYMGLDRAWARRAYSINSTANCEDARBPROC __rglgen_glDrawArraysInstancedARB; +RGLSYMGLDRAWELEMENTSINSTANCEDARBPROC __rglgen_glDrawElementsInstancedARB; +RGLSYMGLPROGRAMSTRINGARBPROC __rglgen_glProgramStringARB; +RGLSYMGLBINDPROGRAMARBPROC __rglgen_glBindProgramARB; +RGLSYMGLDELETEPROGRAMSARBPROC __rglgen_glDeleteProgramsARB; +RGLSYMGLGENPROGRAMSARBPROC __rglgen_glGenProgramsARB; +RGLSYMGLPROGRAMENVPARAMETER4DARBPROC __rglgen_glProgramEnvParameter4dARB; +RGLSYMGLPROGRAMENVPARAMETER4DVARBPROC __rglgen_glProgramEnvParameter4dvARB; +RGLSYMGLPROGRAMENVPARAMETER4FARBPROC __rglgen_glProgramEnvParameter4fARB; +RGLSYMGLPROGRAMENVPARAMETER4FVARBPROC __rglgen_glProgramEnvParameter4fvARB; +RGLSYMGLPROGRAMLOCALPARAMETER4DARBPROC __rglgen_glProgramLocalParameter4dARB; +RGLSYMGLPROGRAMLOCALPARAMETER4DVARBPROC __rglgen_glProgramLocalParameter4dvARB; +RGLSYMGLPROGRAMLOCALPARAMETER4FARBPROC __rglgen_glProgramLocalParameter4fARB; +RGLSYMGLPROGRAMLOCALPARAMETER4FVARBPROC __rglgen_glProgramLocalParameter4fvARB; +RGLSYMGLGETPROGRAMENVPARAMETERDVARBPROC __rglgen_glGetProgramEnvParameterdvARB; +RGLSYMGLGETPROGRAMENVPARAMETERFVARBPROC __rglgen_glGetProgramEnvParameterfvARB; +RGLSYMGLGETPROGRAMLOCALPARAMETERDVARBPROC __rglgen_glGetProgramLocalParameterdvARB; +RGLSYMGLGETPROGRAMLOCALPARAMETERFVARBPROC __rglgen_glGetProgramLocalParameterfvARB; +RGLSYMGLGETPROGRAMIVARBPROC __rglgen_glGetProgramivARB; +RGLSYMGLGETPROGRAMSTRINGARBPROC __rglgen_glGetProgramStringARB; +RGLSYMGLISPROGRAMARBPROC __rglgen_glIsProgramARB; +RGLSYMGLPROGRAMPARAMETERIARBPROC __rglgen_glProgramParameteriARB; +RGLSYMGLFRAMEBUFFERTEXTUREARBPROC __rglgen_glFramebufferTextureARB; +RGLSYMGLFRAMEBUFFERTEXTURELAYERARBPROC __rglgen_glFramebufferTextureLayerARB; +RGLSYMGLFRAMEBUFFERTEXTUREFACEARBPROC __rglgen_glFramebufferTextureFaceARB; +RGLSYMGLCOLORTABLEPROC __rglgen_glColorTable; +RGLSYMGLCOLORTABLEPARAMETERFVPROC __rglgen_glColorTableParameterfv; +RGLSYMGLCOLORTABLEPARAMETERIVPROC __rglgen_glColorTableParameteriv; +RGLSYMGLCOPYCOLORTABLEPROC __rglgen_glCopyColorTable; +RGLSYMGLGETCOLORTABLEPROC __rglgen_glGetColorTable; +RGLSYMGLGETCOLORTABLEPARAMETERFVPROC __rglgen_glGetColorTableParameterfv; +RGLSYMGLGETCOLORTABLEPARAMETERIVPROC __rglgen_glGetColorTableParameteriv; +RGLSYMGLCOLORSUBTABLEPROC __rglgen_glColorSubTable; +RGLSYMGLCOPYCOLORSUBTABLEPROC __rglgen_glCopyColorSubTable; +RGLSYMGLCONVOLUTIONFILTER1DPROC __rglgen_glConvolutionFilter1D; +RGLSYMGLCONVOLUTIONFILTER2DPROC __rglgen_glConvolutionFilter2D; +RGLSYMGLCONVOLUTIONPARAMETERFPROC __rglgen_glConvolutionParameterf; +RGLSYMGLCONVOLUTIONPARAMETERFVPROC __rglgen_glConvolutionParameterfv; +RGLSYMGLCONVOLUTIONPARAMETERIPROC __rglgen_glConvolutionParameteri; +RGLSYMGLCONVOLUTIONPARAMETERIVPROC __rglgen_glConvolutionParameteriv; +RGLSYMGLCOPYCONVOLUTIONFILTER1DPROC __rglgen_glCopyConvolutionFilter1D; +RGLSYMGLCOPYCONVOLUTIONFILTER2DPROC __rglgen_glCopyConvolutionFilter2D; +RGLSYMGLGETCONVOLUTIONFILTERPROC __rglgen_glGetConvolutionFilter; +RGLSYMGLGETCONVOLUTIONPARAMETERFVPROC __rglgen_glGetConvolutionParameterfv; +RGLSYMGLGETCONVOLUTIONPARAMETERIVPROC __rglgen_glGetConvolutionParameteriv; +RGLSYMGLGETSEPARABLEFILTERPROC __rglgen_glGetSeparableFilter; +RGLSYMGLSEPARABLEFILTER2DPROC __rglgen_glSeparableFilter2D; +RGLSYMGLGETHISTOGRAMPROC __rglgen_glGetHistogram; +RGLSYMGLGETHISTOGRAMPARAMETERFVPROC __rglgen_glGetHistogramParameterfv; +RGLSYMGLGETHISTOGRAMPARAMETERIVPROC __rglgen_glGetHistogramParameteriv; +RGLSYMGLGETMINMAXPROC __rglgen_glGetMinmax; +RGLSYMGLGETMINMAXPARAMETERFVPROC __rglgen_glGetMinmaxParameterfv; +RGLSYMGLGETMINMAXPARAMETERIVPROC __rglgen_glGetMinmaxParameteriv; +RGLSYMGLHISTOGRAMPROC __rglgen_glHistogram; +RGLSYMGLMINMAXPROC __rglgen_glMinmax; +RGLSYMGLRESETHISTOGRAMPROC __rglgen_glResetHistogram; +RGLSYMGLRESETMINMAXPROC __rglgen_glResetMinmax; +RGLSYMGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC __rglgen_glMultiDrawArraysIndirectCountARB; +RGLSYMGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC __rglgen_glMultiDrawElementsIndirectCountARB; +RGLSYMGLVERTEXATTRIBDIVISORARBPROC __rglgen_glVertexAttribDivisorARB; +RGLSYMGLCURRENTPALETTEMATRIXARBPROC __rglgen_glCurrentPaletteMatrixARB; +RGLSYMGLMATRIXINDEXUBVARBPROC __rglgen_glMatrixIndexubvARB; +RGLSYMGLMATRIXINDEXUSVARBPROC __rglgen_glMatrixIndexusvARB; +RGLSYMGLMATRIXINDEXUIVARBPROC __rglgen_glMatrixIndexuivARB; +RGLSYMGLMATRIXINDEXPOINTERARBPROC __rglgen_glMatrixIndexPointerARB; +RGLSYMGLSAMPLECOVERAGEARBPROC __rglgen_glSampleCoverageARB; +RGLSYMGLACTIVETEXTUREARBPROC __rglgen_glActiveTextureARB; +RGLSYMGLCLIENTACTIVETEXTUREARBPROC __rglgen_glClientActiveTextureARB; +RGLSYMGLMULTITEXCOORD1DARBPROC __rglgen_glMultiTexCoord1dARB; +RGLSYMGLMULTITEXCOORD1DVARBPROC __rglgen_glMultiTexCoord1dvARB; +RGLSYMGLMULTITEXCOORD1FARBPROC __rglgen_glMultiTexCoord1fARB; +RGLSYMGLMULTITEXCOORD1FVARBPROC __rglgen_glMultiTexCoord1fvARB; +RGLSYMGLMULTITEXCOORD1IARBPROC __rglgen_glMultiTexCoord1iARB; +RGLSYMGLMULTITEXCOORD1IVARBPROC __rglgen_glMultiTexCoord1ivARB; +RGLSYMGLMULTITEXCOORD1SARBPROC __rglgen_glMultiTexCoord1sARB; +RGLSYMGLMULTITEXCOORD1SVARBPROC __rglgen_glMultiTexCoord1svARB; +RGLSYMGLMULTITEXCOORD2DARBPROC __rglgen_glMultiTexCoord2dARB; +RGLSYMGLMULTITEXCOORD2DVARBPROC __rglgen_glMultiTexCoord2dvARB; +RGLSYMGLMULTITEXCOORD2FARBPROC __rglgen_glMultiTexCoord2fARB; +RGLSYMGLMULTITEXCOORD2FVARBPROC __rglgen_glMultiTexCoord2fvARB; +RGLSYMGLMULTITEXCOORD2IARBPROC __rglgen_glMultiTexCoord2iARB; +RGLSYMGLMULTITEXCOORD2IVARBPROC __rglgen_glMultiTexCoord2ivARB; +RGLSYMGLMULTITEXCOORD2SARBPROC __rglgen_glMultiTexCoord2sARB; +RGLSYMGLMULTITEXCOORD2SVARBPROC __rglgen_glMultiTexCoord2svARB; +RGLSYMGLMULTITEXCOORD3DARBPROC __rglgen_glMultiTexCoord3dARB; +RGLSYMGLMULTITEXCOORD3DVARBPROC __rglgen_glMultiTexCoord3dvARB; +RGLSYMGLMULTITEXCOORD3FARBPROC __rglgen_glMultiTexCoord3fARB; +RGLSYMGLMULTITEXCOORD3FVARBPROC __rglgen_glMultiTexCoord3fvARB; +RGLSYMGLMULTITEXCOORD3IARBPROC __rglgen_glMultiTexCoord3iARB; +RGLSYMGLMULTITEXCOORD3IVARBPROC __rglgen_glMultiTexCoord3ivARB; +RGLSYMGLMULTITEXCOORD3SARBPROC __rglgen_glMultiTexCoord3sARB; +RGLSYMGLMULTITEXCOORD3SVARBPROC __rglgen_glMultiTexCoord3svARB; +RGLSYMGLMULTITEXCOORD4DARBPROC __rglgen_glMultiTexCoord4dARB; +RGLSYMGLMULTITEXCOORD4DVARBPROC __rglgen_glMultiTexCoord4dvARB; +RGLSYMGLMULTITEXCOORD4FARBPROC __rglgen_glMultiTexCoord4fARB; +RGLSYMGLMULTITEXCOORD4FVARBPROC __rglgen_glMultiTexCoord4fvARB; +RGLSYMGLMULTITEXCOORD4IARBPROC __rglgen_glMultiTexCoord4iARB; +RGLSYMGLMULTITEXCOORD4IVARBPROC __rglgen_glMultiTexCoord4ivARB; +RGLSYMGLMULTITEXCOORD4SARBPROC __rglgen_glMultiTexCoord4sARB; +RGLSYMGLMULTITEXCOORD4SVARBPROC __rglgen_glMultiTexCoord4svARB; +RGLSYMGLGENQUERIESARBPROC __rglgen_glGenQueriesARB; +RGLSYMGLDELETEQUERIESARBPROC __rglgen_glDeleteQueriesARB; +RGLSYMGLISQUERYARBPROC __rglgen_glIsQueryARB; +RGLSYMGLBEGINQUERYARBPROC __rglgen_glBeginQueryARB; +RGLSYMGLENDQUERYARBPROC __rglgen_glEndQueryARB; +RGLSYMGLGETQUERYIVARBPROC __rglgen_glGetQueryivARB; +RGLSYMGLGETQUERYOBJECTIVARBPROC __rglgen_glGetQueryObjectivARB; +RGLSYMGLGETQUERYOBJECTUIVARBPROC __rglgen_glGetQueryObjectuivARB; +RGLSYMGLPOINTPARAMETERFARBPROC __rglgen_glPointParameterfARB; +RGLSYMGLPOINTPARAMETERFVARBPROC __rglgen_glPointParameterfvARB; +RGLSYMGLGETGRAPHICSRESETSTATUSARBPROC __rglgen_glGetGraphicsResetStatusARB; +RGLSYMGLGETNTEXIMAGEARBPROC __rglgen_glGetnTexImageARB; +RGLSYMGLREADNPIXELSARBPROC __rglgen_glReadnPixelsARB; +RGLSYMGLGETNCOMPRESSEDTEXIMAGEARBPROC __rglgen_glGetnCompressedTexImageARB; +RGLSYMGLGETNUNIFORMFVARBPROC __rglgen_glGetnUniformfvARB; +RGLSYMGLGETNUNIFORMIVARBPROC __rglgen_glGetnUniformivARB; +RGLSYMGLGETNUNIFORMUIVARBPROC __rglgen_glGetnUniformuivARB; +RGLSYMGLGETNUNIFORMDVARBPROC __rglgen_glGetnUniformdvARB; +RGLSYMGLGETNMAPDVARBPROC __rglgen_glGetnMapdvARB; +RGLSYMGLGETNMAPFVARBPROC __rglgen_glGetnMapfvARB; +RGLSYMGLGETNMAPIVARBPROC __rglgen_glGetnMapivARB; +RGLSYMGLGETNPIXELMAPFVARBPROC __rglgen_glGetnPixelMapfvARB; +RGLSYMGLGETNPIXELMAPUIVARBPROC __rglgen_glGetnPixelMapuivARB; +RGLSYMGLGETNPIXELMAPUSVARBPROC __rglgen_glGetnPixelMapusvARB; +RGLSYMGLGETNPOLYGONSTIPPLEARBPROC __rglgen_glGetnPolygonStippleARB; +RGLSYMGLGETNCOLORTABLEARBPROC __rglgen_glGetnColorTableARB; +RGLSYMGLGETNCONVOLUTIONFILTERARBPROC __rglgen_glGetnConvolutionFilterARB; +RGLSYMGLGETNSEPARABLEFILTERARBPROC __rglgen_glGetnSeparableFilterARB; +RGLSYMGLGETNHISTOGRAMARBPROC __rglgen_glGetnHistogramARB; +RGLSYMGLGETNMINMAXARBPROC __rglgen_glGetnMinmaxARB; +RGLSYMGLMINSAMPLESHADINGARBPROC __rglgen_glMinSampleShadingARB; +RGLSYMGLDELETEOBJECTARBPROC __rglgen_glDeleteObjectARB; +RGLSYMGLGETHANDLEARBPROC __rglgen_glGetHandleARB; +RGLSYMGLDETACHOBJECTARBPROC __rglgen_glDetachObjectARB; +RGLSYMGLCREATESHADEROBJECTARBPROC __rglgen_glCreateShaderObjectARB; +RGLSYMGLSHADERSOURCEARBPROC __rglgen_glShaderSourceARB; +RGLSYMGLCOMPILESHADERARBPROC __rglgen_glCompileShaderARB; +RGLSYMGLCREATEPROGRAMOBJECTARBPROC __rglgen_glCreateProgramObjectARB; +RGLSYMGLATTACHOBJECTARBPROC __rglgen_glAttachObjectARB; +RGLSYMGLLINKPROGRAMARBPROC __rglgen_glLinkProgramARB; +RGLSYMGLUSEPROGRAMOBJECTARBPROC __rglgen_glUseProgramObjectARB; +RGLSYMGLVALIDATEPROGRAMARBPROC __rglgen_glValidateProgramARB; +RGLSYMGLUNIFORM1FARBPROC __rglgen_glUniform1fARB; +RGLSYMGLUNIFORM2FARBPROC __rglgen_glUniform2fARB; +RGLSYMGLUNIFORM3FARBPROC __rglgen_glUniform3fARB; +RGLSYMGLUNIFORM4FARBPROC __rglgen_glUniform4fARB; +RGLSYMGLUNIFORM1IARBPROC __rglgen_glUniform1iARB; +RGLSYMGLUNIFORM2IARBPROC __rglgen_glUniform2iARB; +RGLSYMGLUNIFORM3IARBPROC __rglgen_glUniform3iARB; +RGLSYMGLUNIFORM4IARBPROC __rglgen_glUniform4iARB; +RGLSYMGLUNIFORM1FVARBPROC __rglgen_glUniform1fvARB; +RGLSYMGLUNIFORM2FVARBPROC __rglgen_glUniform2fvARB; +RGLSYMGLUNIFORM3FVARBPROC __rglgen_glUniform3fvARB; +RGLSYMGLUNIFORM4FVARBPROC __rglgen_glUniform4fvARB; +RGLSYMGLUNIFORM1IVARBPROC __rglgen_glUniform1ivARB; +RGLSYMGLUNIFORM2IVARBPROC __rglgen_glUniform2ivARB; +RGLSYMGLUNIFORM3IVARBPROC __rglgen_glUniform3ivARB; +RGLSYMGLUNIFORM4IVARBPROC __rglgen_glUniform4ivARB; +RGLSYMGLUNIFORMMATRIX2FVARBPROC __rglgen_glUniformMatrix2fvARB; +RGLSYMGLUNIFORMMATRIX3FVARBPROC __rglgen_glUniformMatrix3fvARB; +RGLSYMGLUNIFORMMATRIX4FVARBPROC __rglgen_glUniformMatrix4fvARB; +RGLSYMGLGETOBJECTPARAMETERFVARBPROC __rglgen_glGetObjectParameterfvARB; +RGLSYMGLGETOBJECTPARAMETERIVARBPROC __rglgen_glGetObjectParameterivARB; +RGLSYMGLGETINFOLOGARBPROC __rglgen_glGetInfoLogARB; +RGLSYMGLGETATTACHEDOBJECTSARBPROC __rglgen_glGetAttachedObjectsARB; +RGLSYMGLGETUNIFORMLOCATIONARBPROC __rglgen_glGetUniformLocationARB; +RGLSYMGLGETACTIVEUNIFORMARBPROC __rglgen_glGetActiveUniformARB; +RGLSYMGLGETUNIFORMFVARBPROC __rglgen_glGetUniformfvARB; +RGLSYMGLGETUNIFORMIVARBPROC __rglgen_glGetUniformivARB; +RGLSYMGLGETSHADERSOURCEARBPROC __rglgen_glGetShaderSourceARB; +RGLSYMGLNAMEDSTRINGARBPROC __rglgen_glNamedStringARB; +RGLSYMGLDELETENAMEDSTRINGARBPROC __rglgen_glDeleteNamedStringARB; +RGLSYMGLCOMPILESHADERINCLUDEARBPROC __rglgen_glCompileShaderIncludeARB; +RGLSYMGLISNAMEDSTRINGARBPROC __rglgen_glIsNamedStringARB; +RGLSYMGLGETNAMEDSTRINGARBPROC __rglgen_glGetNamedStringARB; +RGLSYMGLGETNAMEDSTRINGIVARBPROC __rglgen_glGetNamedStringivARB; +RGLSYMGLTEXPAGECOMMITMENTARBPROC __rglgen_glTexPageCommitmentARB; +RGLSYMGLTEXBUFFERARBPROC __rglgen_glTexBufferARB; +RGLSYMGLCOMPRESSEDTEXIMAGE3DARBPROC __rglgen_glCompressedTexImage3DARB; +RGLSYMGLCOMPRESSEDTEXIMAGE2DARBPROC __rglgen_glCompressedTexImage2DARB; +RGLSYMGLCOMPRESSEDTEXIMAGE1DARBPROC __rglgen_glCompressedTexImage1DARB; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __rglgen_glCompressedTexSubImage3DARB; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __rglgen_glCompressedTexSubImage2DARB; +RGLSYMGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __rglgen_glCompressedTexSubImage1DARB; +RGLSYMGLGETCOMPRESSEDTEXIMAGEARBPROC __rglgen_glGetCompressedTexImageARB; +RGLSYMGLLOADTRANSPOSEMATRIXFARBPROC __rglgen_glLoadTransposeMatrixfARB; +RGLSYMGLLOADTRANSPOSEMATRIXDARBPROC __rglgen_glLoadTransposeMatrixdARB; +RGLSYMGLMULTTRANSPOSEMATRIXFARBPROC __rglgen_glMultTransposeMatrixfARB; +RGLSYMGLMULTTRANSPOSEMATRIXDARBPROC __rglgen_glMultTransposeMatrixdARB; +RGLSYMGLWEIGHTBVARBPROC __rglgen_glWeightbvARB; +RGLSYMGLWEIGHTSVARBPROC __rglgen_glWeightsvARB; +RGLSYMGLWEIGHTIVARBPROC __rglgen_glWeightivARB; +RGLSYMGLWEIGHTFVARBPROC __rglgen_glWeightfvARB; +RGLSYMGLWEIGHTDVARBPROC __rglgen_glWeightdvARB; +RGLSYMGLWEIGHTUBVARBPROC __rglgen_glWeightubvARB; +RGLSYMGLWEIGHTUSVARBPROC __rglgen_glWeightusvARB; +RGLSYMGLWEIGHTUIVARBPROC __rglgen_glWeightuivARB; +RGLSYMGLWEIGHTPOINTERARBPROC __rglgen_glWeightPointerARB; +RGLSYMGLVERTEXBLENDARBPROC __rglgen_glVertexBlendARB; +RGLSYMGLBINDBUFFERARBPROC __rglgen_glBindBufferARB; +RGLSYMGLDELETEBUFFERSARBPROC __rglgen_glDeleteBuffersARB; +RGLSYMGLGENBUFFERSARBPROC __rglgen_glGenBuffersARB; +RGLSYMGLISBUFFERARBPROC __rglgen_glIsBufferARB; +RGLSYMGLBUFFERDATAARBPROC __rglgen_glBufferDataARB; +RGLSYMGLBUFFERSUBDATAARBPROC __rglgen_glBufferSubDataARB; +RGLSYMGLGETBUFFERSUBDATAARBPROC __rglgen_glGetBufferSubDataARB; +RGLSYMGLMAPBUFFERARBPROC __rglgen_glMapBufferARB; +RGLSYMGLUNMAPBUFFERARBPROC __rglgen_glUnmapBufferARB; +RGLSYMGLGETBUFFERPARAMETERIVARBPROC __rglgen_glGetBufferParameterivARB; +RGLSYMGLGETBUFFERPOINTERVARBPROC __rglgen_glGetBufferPointervARB; +RGLSYMGLVERTEXATTRIB1DARBPROC __rglgen_glVertexAttrib1dARB; +RGLSYMGLVERTEXATTRIB1DVARBPROC __rglgen_glVertexAttrib1dvARB; +RGLSYMGLVERTEXATTRIB1FARBPROC __rglgen_glVertexAttrib1fARB; +RGLSYMGLVERTEXATTRIB1FVARBPROC __rglgen_glVertexAttrib1fvARB; +RGLSYMGLVERTEXATTRIB1SARBPROC __rglgen_glVertexAttrib1sARB; +RGLSYMGLVERTEXATTRIB1SVARBPROC __rglgen_glVertexAttrib1svARB; +RGLSYMGLVERTEXATTRIB2DARBPROC __rglgen_glVertexAttrib2dARB; +RGLSYMGLVERTEXATTRIB2DVARBPROC __rglgen_glVertexAttrib2dvARB; +RGLSYMGLVERTEXATTRIB2FARBPROC __rglgen_glVertexAttrib2fARB; +RGLSYMGLVERTEXATTRIB2FVARBPROC __rglgen_glVertexAttrib2fvARB; +RGLSYMGLVERTEXATTRIB2SARBPROC __rglgen_glVertexAttrib2sARB; +RGLSYMGLVERTEXATTRIB2SVARBPROC __rglgen_glVertexAttrib2svARB; +RGLSYMGLVERTEXATTRIB3DARBPROC __rglgen_glVertexAttrib3dARB; +RGLSYMGLVERTEXATTRIB3DVARBPROC __rglgen_glVertexAttrib3dvARB; +RGLSYMGLVERTEXATTRIB3FARBPROC __rglgen_glVertexAttrib3fARB; +RGLSYMGLVERTEXATTRIB3FVARBPROC __rglgen_glVertexAttrib3fvARB; +RGLSYMGLVERTEXATTRIB3SARBPROC __rglgen_glVertexAttrib3sARB; +RGLSYMGLVERTEXATTRIB3SVARBPROC __rglgen_glVertexAttrib3svARB; +RGLSYMGLVERTEXATTRIB4NBVARBPROC __rglgen_glVertexAttrib4NbvARB; +RGLSYMGLVERTEXATTRIB4NIVARBPROC __rglgen_glVertexAttrib4NivARB; +RGLSYMGLVERTEXATTRIB4NSVARBPROC __rglgen_glVertexAttrib4NsvARB; +RGLSYMGLVERTEXATTRIB4NUBARBPROC __rglgen_glVertexAttrib4NubARB; +RGLSYMGLVERTEXATTRIB4NUBVARBPROC __rglgen_glVertexAttrib4NubvARB; +RGLSYMGLVERTEXATTRIB4NUIVARBPROC __rglgen_glVertexAttrib4NuivARB; +RGLSYMGLVERTEXATTRIB4NUSVARBPROC __rglgen_glVertexAttrib4NusvARB; +RGLSYMGLVERTEXATTRIB4BVARBPROC __rglgen_glVertexAttrib4bvARB; +RGLSYMGLVERTEXATTRIB4DARBPROC __rglgen_glVertexAttrib4dARB; +RGLSYMGLVERTEXATTRIB4DVARBPROC __rglgen_glVertexAttrib4dvARB; +RGLSYMGLVERTEXATTRIB4FARBPROC __rglgen_glVertexAttrib4fARB; +RGLSYMGLVERTEXATTRIB4FVARBPROC __rglgen_glVertexAttrib4fvARB; +RGLSYMGLVERTEXATTRIB4IVARBPROC __rglgen_glVertexAttrib4ivARB; +RGLSYMGLVERTEXATTRIB4SARBPROC __rglgen_glVertexAttrib4sARB; +RGLSYMGLVERTEXATTRIB4SVARBPROC __rglgen_glVertexAttrib4svARB; +RGLSYMGLVERTEXATTRIB4UBVARBPROC __rglgen_glVertexAttrib4ubvARB; +RGLSYMGLVERTEXATTRIB4UIVARBPROC __rglgen_glVertexAttrib4uivARB; +RGLSYMGLVERTEXATTRIB4USVARBPROC __rglgen_glVertexAttrib4usvARB; +RGLSYMGLVERTEXATTRIBPOINTERARBPROC __rglgen_glVertexAttribPointerARB; +RGLSYMGLENABLEVERTEXATTRIBARRAYARBPROC __rglgen_glEnableVertexAttribArrayARB; +RGLSYMGLDISABLEVERTEXATTRIBARRAYARBPROC __rglgen_glDisableVertexAttribArrayARB; +RGLSYMGLGETVERTEXATTRIBDVARBPROC __rglgen_glGetVertexAttribdvARB; +RGLSYMGLGETVERTEXATTRIBFVARBPROC __rglgen_glGetVertexAttribfvARB; +RGLSYMGLGETVERTEXATTRIBIVARBPROC __rglgen_glGetVertexAttribivARB; +RGLSYMGLGETVERTEXATTRIBPOINTERVARBPROC __rglgen_glGetVertexAttribPointervARB; +RGLSYMGLBINDATTRIBLOCATIONARBPROC __rglgen_glBindAttribLocationARB; +RGLSYMGLGETACTIVEATTRIBARBPROC __rglgen_glGetActiveAttribARB; +RGLSYMGLGETATTRIBLOCATIONARBPROC __rglgen_glGetAttribLocationARB; +RGLSYMGLWINDOWPOS2DARBPROC __rglgen_glWindowPos2dARB; +RGLSYMGLWINDOWPOS2DVARBPROC __rglgen_glWindowPos2dvARB; +RGLSYMGLWINDOWPOS2FARBPROC __rglgen_glWindowPos2fARB; +RGLSYMGLWINDOWPOS2FVARBPROC __rglgen_glWindowPos2fvARB; +RGLSYMGLWINDOWPOS2IARBPROC __rglgen_glWindowPos2iARB; +RGLSYMGLWINDOWPOS2IVARBPROC __rglgen_glWindowPos2ivARB; +RGLSYMGLWINDOWPOS2SARBPROC __rglgen_glWindowPos2sARB; +RGLSYMGLWINDOWPOS2SVARBPROC __rglgen_glWindowPos2svARB; +RGLSYMGLWINDOWPOS3DARBPROC __rglgen_glWindowPos3dARB; +RGLSYMGLWINDOWPOS3DVARBPROC __rglgen_glWindowPos3dvARB; +RGLSYMGLWINDOWPOS3FARBPROC __rglgen_glWindowPos3fARB; +RGLSYMGLWINDOWPOS3FVARBPROC __rglgen_glWindowPos3fvARB; +RGLSYMGLWINDOWPOS3IARBPROC __rglgen_glWindowPos3iARB; +RGLSYMGLWINDOWPOS3IVARBPROC __rglgen_glWindowPos3ivARB; +RGLSYMGLWINDOWPOS3SARBPROC __rglgen_glWindowPos3sARB; +RGLSYMGLWINDOWPOS3SVARBPROC __rglgen_glWindowPos3svARB; +RGLSYMGLMULTITEXCOORD1BOESPROC __rglgen_glMultiTexCoord1bOES; +RGLSYMGLMULTITEXCOORD1BVOESPROC __rglgen_glMultiTexCoord1bvOES; +RGLSYMGLMULTITEXCOORD2BOESPROC __rglgen_glMultiTexCoord2bOES; +RGLSYMGLMULTITEXCOORD2BVOESPROC __rglgen_glMultiTexCoord2bvOES; +RGLSYMGLMULTITEXCOORD3BOESPROC __rglgen_glMultiTexCoord3bOES; +RGLSYMGLMULTITEXCOORD3BVOESPROC __rglgen_glMultiTexCoord3bvOES; +RGLSYMGLMULTITEXCOORD4BOESPROC __rglgen_glMultiTexCoord4bOES; +RGLSYMGLMULTITEXCOORD4BVOESPROC __rglgen_glMultiTexCoord4bvOES; +RGLSYMGLTEXCOORD1BOESPROC __rglgen_glTexCoord1bOES; +RGLSYMGLTEXCOORD1BVOESPROC __rglgen_glTexCoord1bvOES; +RGLSYMGLTEXCOORD2BOESPROC __rglgen_glTexCoord2bOES; +RGLSYMGLTEXCOORD2BVOESPROC __rglgen_glTexCoord2bvOES; +RGLSYMGLTEXCOORD3BOESPROC __rglgen_glTexCoord3bOES; +RGLSYMGLTEXCOORD3BVOESPROC __rglgen_glTexCoord3bvOES; +RGLSYMGLTEXCOORD4BOESPROC __rglgen_glTexCoord4bOES; +RGLSYMGLTEXCOORD4BVOESPROC __rglgen_glTexCoord4bvOES; +RGLSYMGLVERTEX2BOESPROC __rglgen_glVertex2bOES; +RGLSYMGLVERTEX2BVOESPROC __rglgen_glVertex2bvOES; +RGLSYMGLVERTEX3BOESPROC __rglgen_glVertex3bOES; +RGLSYMGLVERTEX3BVOESPROC __rglgen_glVertex3bvOES; +RGLSYMGLVERTEX4BOESPROC __rglgen_glVertex4bOES; +RGLSYMGLVERTEX4BVOESPROC __rglgen_glVertex4bvOES; +RGLSYMGLALPHAFUNCXOESPROC __rglgen_glAlphaFuncxOES; +RGLSYMGLCLEARCOLORXOESPROC __rglgen_glClearColorxOES; +RGLSYMGLCLEARDEPTHXOESPROC __rglgen_glClearDepthxOES; +RGLSYMGLCLIPPLANEXOESPROC __rglgen_glClipPlanexOES; +RGLSYMGLCOLOR4XOESPROC __rglgen_glColor4xOES; +RGLSYMGLDEPTHRANGEXOESPROC __rglgen_glDepthRangexOES; +RGLSYMGLFOGXOESPROC __rglgen_glFogxOES; +RGLSYMGLFOGXVOESPROC __rglgen_glFogxvOES; +RGLSYMGLFRUSTUMXOESPROC __rglgen_glFrustumxOES; +RGLSYMGLGETCLIPPLANEXOESPROC __rglgen_glGetClipPlanexOES; +RGLSYMGLGETFIXEDVOESPROC __rglgen_glGetFixedvOES; +RGLSYMGLGETTEXENVXVOESPROC __rglgen_glGetTexEnvxvOES; +RGLSYMGLGETTEXPARAMETERXVOESPROC __rglgen_glGetTexParameterxvOES; +RGLSYMGLLIGHTMODELXOESPROC __rglgen_glLightModelxOES; +RGLSYMGLLIGHTMODELXVOESPROC __rglgen_glLightModelxvOES; +RGLSYMGLLIGHTXOESPROC __rglgen_glLightxOES; +RGLSYMGLLIGHTXVOESPROC __rglgen_glLightxvOES; +RGLSYMGLLINEWIDTHXOESPROC __rglgen_glLineWidthxOES; +RGLSYMGLLOADMATRIXXOESPROC __rglgen_glLoadMatrixxOES; +RGLSYMGLMATERIALXOESPROC __rglgen_glMaterialxOES; +RGLSYMGLMATERIALXVOESPROC __rglgen_glMaterialxvOES; +RGLSYMGLMULTMATRIXXOESPROC __rglgen_glMultMatrixxOES; +RGLSYMGLMULTITEXCOORD4XOESPROC __rglgen_glMultiTexCoord4xOES; +RGLSYMGLNORMAL3XOESPROC __rglgen_glNormal3xOES; +RGLSYMGLORTHOXOESPROC __rglgen_glOrthoxOES; +RGLSYMGLPOINTPARAMETERXVOESPROC __rglgen_glPointParameterxvOES; +RGLSYMGLPOINTSIZEXOESPROC __rglgen_glPointSizexOES; +RGLSYMGLPOLYGONOFFSETXOESPROC __rglgen_glPolygonOffsetxOES; +RGLSYMGLROTATEXOESPROC __rglgen_glRotatexOES; +RGLSYMGLSAMPLECOVERAGEOESPROC __rglgen_glSampleCoverageOES; +RGLSYMGLSCALEXOESPROC __rglgen_glScalexOES; +RGLSYMGLTEXENVXOESPROC __rglgen_glTexEnvxOES; +RGLSYMGLTEXENVXVOESPROC __rglgen_glTexEnvxvOES; +RGLSYMGLTEXPARAMETERXOESPROC __rglgen_glTexParameterxOES; +RGLSYMGLTEXPARAMETERXVOESPROC __rglgen_glTexParameterxvOES; +RGLSYMGLTRANSLATEXOESPROC __rglgen_glTranslatexOES; +RGLSYMGLACCUMXOESPROC __rglgen_glAccumxOES; +RGLSYMGLBITMAPXOESPROC __rglgen_glBitmapxOES; +RGLSYMGLBLENDCOLORXOESPROC __rglgen_glBlendColorxOES; +RGLSYMGLCLEARACCUMXOESPROC __rglgen_glClearAccumxOES; +RGLSYMGLCOLOR3XOESPROC __rglgen_glColor3xOES; +RGLSYMGLCOLOR3XVOESPROC __rglgen_glColor3xvOES; +RGLSYMGLCOLOR4XVOESPROC __rglgen_glColor4xvOES; +RGLSYMGLCONVOLUTIONPARAMETERXOESPROC __rglgen_glConvolutionParameterxOES; +RGLSYMGLCONVOLUTIONPARAMETERXVOESPROC __rglgen_glConvolutionParameterxvOES; +RGLSYMGLEVALCOORD1XOESPROC __rglgen_glEvalCoord1xOES; +RGLSYMGLEVALCOORD1XVOESPROC __rglgen_glEvalCoord1xvOES; +RGLSYMGLEVALCOORD2XOESPROC __rglgen_glEvalCoord2xOES; +RGLSYMGLEVALCOORD2XVOESPROC __rglgen_glEvalCoord2xvOES; +RGLSYMGLFEEDBACKBUFFERXOESPROC __rglgen_glFeedbackBufferxOES; +RGLSYMGLGETCONVOLUTIONPARAMETERXVOESPROC __rglgen_glGetConvolutionParameterxvOES; +RGLSYMGLGETHISTOGRAMPARAMETERXVOESPROC __rglgen_glGetHistogramParameterxvOES; +RGLSYMGLGETLIGHTXOESPROC __rglgen_glGetLightxOES; +RGLSYMGLGETMAPXVOESPROC __rglgen_glGetMapxvOES; +RGLSYMGLGETMATERIALXOESPROC __rglgen_glGetMaterialxOES; +RGLSYMGLGETPIXELMAPXVPROC __rglgen_glGetPixelMapxv; +RGLSYMGLGETTEXGENXVOESPROC __rglgen_glGetTexGenxvOES; +RGLSYMGLGETTEXLEVELPARAMETERXVOESPROC __rglgen_glGetTexLevelParameterxvOES; +RGLSYMGLINDEXXOESPROC __rglgen_glIndexxOES; +RGLSYMGLINDEXXVOESPROC __rglgen_glIndexxvOES; +RGLSYMGLLOADTRANSPOSEMATRIXXOESPROC __rglgen_glLoadTransposeMatrixxOES; +RGLSYMGLMAP1XOESPROC __rglgen_glMap1xOES; +RGLSYMGLMAP2XOESPROC __rglgen_glMap2xOES; +RGLSYMGLMAPGRID1XOESPROC __rglgen_glMapGrid1xOES; +RGLSYMGLMAPGRID2XOESPROC __rglgen_glMapGrid2xOES; +RGLSYMGLMULTTRANSPOSEMATRIXXOESPROC __rglgen_glMultTransposeMatrixxOES; +RGLSYMGLMULTITEXCOORD1XOESPROC __rglgen_glMultiTexCoord1xOES; +RGLSYMGLMULTITEXCOORD1XVOESPROC __rglgen_glMultiTexCoord1xvOES; +RGLSYMGLMULTITEXCOORD2XOESPROC __rglgen_glMultiTexCoord2xOES; +RGLSYMGLMULTITEXCOORD2XVOESPROC __rglgen_glMultiTexCoord2xvOES; +RGLSYMGLMULTITEXCOORD3XOESPROC __rglgen_glMultiTexCoord3xOES; +RGLSYMGLMULTITEXCOORD3XVOESPROC __rglgen_glMultiTexCoord3xvOES; +RGLSYMGLMULTITEXCOORD4XVOESPROC __rglgen_glMultiTexCoord4xvOES; +RGLSYMGLNORMAL3XVOESPROC __rglgen_glNormal3xvOES; +RGLSYMGLPASSTHROUGHXOESPROC __rglgen_glPassThroughxOES; +RGLSYMGLPIXELMAPXPROC __rglgen_glPixelMapx; +RGLSYMGLPIXELSTOREXPROC __rglgen_glPixelStorex; +RGLSYMGLPIXELTRANSFERXOESPROC __rglgen_glPixelTransferxOES; +RGLSYMGLPIXELZOOMXOESPROC __rglgen_glPixelZoomxOES; +RGLSYMGLPRIORITIZETEXTURESXOESPROC __rglgen_glPrioritizeTexturesxOES; +RGLSYMGLRASTERPOS2XOESPROC __rglgen_glRasterPos2xOES; +RGLSYMGLRASTERPOS2XVOESPROC __rglgen_glRasterPos2xvOES; +RGLSYMGLRASTERPOS3XOESPROC __rglgen_glRasterPos3xOES; +RGLSYMGLRASTERPOS3XVOESPROC __rglgen_glRasterPos3xvOES; +RGLSYMGLRASTERPOS4XOESPROC __rglgen_glRasterPos4xOES; +RGLSYMGLRASTERPOS4XVOESPROC __rglgen_glRasterPos4xvOES; +RGLSYMGLRECTXOESPROC __rglgen_glRectxOES; +RGLSYMGLRECTXVOESPROC __rglgen_glRectxvOES; +RGLSYMGLTEXCOORD1XOESPROC __rglgen_glTexCoord1xOES; +RGLSYMGLTEXCOORD1XVOESPROC __rglgen_glTexCoord1xvOES; +RGLSYMGLTEXCOORD2XOESPROC __rglgen_glTexCoord2xOES; +RGLSYMGLTEXCOORD2XVOESPROC __rglgen_glTexCoord2xvOES; +RGLSYMGLTEXCOORD3XOESPROC __rglgen_glTexCoord3xOES; +RGLSYMGLTEXCOORD3XVOESPROC __rglgen_glTexCoord3xvOES; +RGLSYMGLTEXCOORD4XOESPROC __rglgen_glTexCoord4xOES; +RGLSYMGLTEXCOORD4XVOESPROC __rglgen_glTexCoord4xvOES; +RGLSYMGLTEXGENXOESPROC __rglgen_glTexGenxOES; +RGLSYMGLTEXGENXVOESPROC __rglgen_glTexGenxvOES; +RGLSYMGLVERTEX2XOESPROC __rglgen_glVertex2xOES; +RGLSYMGLVERTEX2XVOESPROC __rglgen_glVertex2xvOES; +RGLSYMGLVERTEX3XOESPROC __rglgen_glVertex3xOES; +RGLSYMGLVERTEX3XVOESPROC __rglgen_glVertex3xvOES; +RGLSYMGLVERTEX4XOESPROC __rglgen_glVertex4xOES; +RGLSYMGLVERTEX4XVOESPROC __rglgen_glVertex4xvOES; +RGLSYMGLQUERYMATRIXXOESPROC __rglgen_glQueryMatrixxOES; +RGLSYMGLCLEARDEPTHFOESPROC __rglgen_glClearDepthfOES; +RGLSYMGLCLIPPLANEFOESPROC __rglgen_glClipPlanefOES; +RGLSYMGLDEPTHRANGEFOESPROC __rglgen_glDepthRangefOES; +RGLSYMGLFRUSTUMFOESPROC __rglgen_glFrustumfOES; +RGLSYMGLGETCLIPPLANEFOESPROC __rglgen_glGetClipPlanefOES; +RGLSYMGLORTHOFOESPROC __rglgen_glOrthofOES; +RGLSYMGLIMAGETRANSFORMPARAMETERIHPPROC __rglgen_glImageTransformParameteriHP; +RGLSYMGLIMAGETRANSFORMPARAMETERFHPPROC __rglgen_glImageTransformParameterfHP; +RGLSYMGLIMAGETRANSFORMPARAMETERIVHPPROC __rglgen_glImageTransformParameterivHP; +RGLSYMGLIMAGETRANSFORMPARAMETERFVHPPROC __rglgen_glImageTransformParameterfvHP; +RGLSYMGLGETIMAGETRANSFORMPARAMETERIVHPPROC __rglgen_glGetImageTransformParameterivHP; +RGLSYMGLGETIMAGETRANSFORMPARAMETERFVHPPROC __rglgen_glGetImageTransformParameterfvHP; diff --git a/src/libretro/libretro-common/glsym/rglgen.c b/src/libretro/libretro-common/glsym/rglgen.c new file mode 100644 index 00000000..d1c4119d --- /dev/null +++ b/src/libretro/libretro-common/glsym/rglgen.c @@ -0,0 +1,45 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this libretro SDK code part (glsym). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include +#include + +void rglgen_resolve_symbols_custom(rglgen_proc_address_t proc, + const struct rglgen_sym_map *map) +{ + for (; map->sym; map++) + { + rglgen_func_t func = proc(map->sym); + memcpy(map->ptr, &func, sizeof(func)); + } +} + +void rglgen_resolve_symbols(rglgen_proc_address_t proc) +{ + if (!proc) + return; + + rglgen_resolve_symbols_custom(proc, rglgen_symbol_map); +} diff --git a/src/libretro/libretro-common/glsym/rglgen.py b/src/libretro/libretro-common/glsym/rglgen.py new file mode 100755 index 00000000..ee43be2c --- /dev/null +++ b/src/libretro/libretro-common/glsym/rglgen.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 + +""" + License statement applies to this file (glgen.py) only. + + Permission is hereby granted, free of charge, + to any person obtaining a copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation the rights to + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +""" + +import sys +import os +import re + +banned_ext = [ 'AMD', 'APPLE', 'NV', 'NVX', 'ATI', '3DLABS', 'SUN', 'SGI', 'SGIX', 'SGIS', 'INTEL', '3DFX', 'IBM', 'MESA', 'GREMEDY', 'OML', 'PGI', 'I3D', 'INGL', 'MTX', 'QCOM', 'IMG', 'ANGLE', 'SUNX', 'INGR' ] + +def noext(sym): + for ext in banned_ext: + if sym.endswith(ext): + return False + return True + +def fix_multiline_functions(lines): + fixed_lines = [] + temp_lines = [] + for line in lines: + if line.count('(') > line.count(')'): + temp_lines.append(line) + else: + if len(temp_lines) > 0: + if line.count(')') > line.count('('): + temp_lines.append(line) + fixed_line = re.sub(' +',' ', ''.join(temp_lines).replace('\n','').replace('\t','')) + fixed_lines.append(fixed_line) + temp_lines = [] + else: + temp_lines.append(line) + else: + fixed_lines.append(line) + return fixed_lines + +def find_gl_symbols(lines): + typedefs = [] + syms = [] + for line in lines: + m = re.search(r'^typedef.+PFN(\S+)PROC.+$', line) + g = re.search(r'^.+(gl\S+)\W*\(.+\).*$', line) + if m and noext(m.group(1)): + typedefs.append(m.group(0).replace('PFN', 'RGLSYM').replace('GLDEBUGPROC', 'RGLGENGLDEBUGPROC')) + if g and noext(g.group(1)): + syms.append(g.group(1)) + return (typedefs, syms) + +def generate_defines(gl_syms): + res = [] + for line in gl_syms: + res.append('#define {} __rglgen_{}'.format(line, line)) + return res + +def generate_declarations(gl_syms): + return ['RGLSYM' + x.upper() + 'PROC ' + '__rglgen_' + x + ';' for x in gl_syms] + +def generate_macros(gl_syms): + return [' SYM(' + x.replace('gl', '') + '),' for x in gl_syms] + +def dump(f, lines): + f.write('\n'.join(lines)) + f.write('\n\n') + +if __name__ == '__main__': + + if len(sys.argv) > 4: + for banned in sys.argv[4:]: + banned_ext.append(banned) + + with open(sys.argv[1], 'r') as f: + lines = fix_multiline_functions(f.readlines()) + typedefs, syms = find_gl_symbols(lines) + + overrides = generate_defines(syms) + declarations = generate_declarations(syms) + externs = ['extern ' + x for x in declarations] + + macros = generate_macros(syms) + + with open(sys.argv[2], 'w') as f: + f.write('#ifndef RGLGEN_DECL_H__\n') + f.write('#define RGLGEN_DECL_H__\n') + + f.write('#ifdef __cplusplus\n') + f.write('extern "C" {\n') + f.write('#endif\n') + + f.write('#ifdef GL_APIENTRY\n') + f.write('typedef void (GL_APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#else\n') + f.write('#ifndef APIENTRY\n') + f.write('#define APIENTRY\n') + f.write('#endif\n') + f.write('#ifndef APIENTRYP\n') + f.write('#define APIENTRYP APIENTRY *\n') + f.write('#endif\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROCARB)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#endif\n') + + f.write('#ifndef GL_OES_EGL_image\n') + f.write('typedef void *GLeglImageOES;\n') + f.write('#endif\n') + + f.write('#if !defined(GL_OES_fixed_point) && !defined(HAVE_OPENGLES2)\n') + f.write('typedef GLint GLfixed;\n') + f.write('#endif\n') + + dump(f, typedefs) + dump(f, overrides) + dump(f, externs) + + f.write('struct rglgen_sym_map { const char *sym; void *ptr; };\n') + f.write('extern const struct rglgen_sym_map rglgen_symbol_map[];\n') + + f.write('#ifdef __cplusplus\n') + f.write('}\n') + f.write('#endif\n') + + f.write('#endif\n') + + with open(sys.argv[3], 'w') as f: + f.write('#include "glsym/glsym.h"\n') + f.write('#include \n') + f.write('#define SYM(x) { "gl" #x, &(gl##x) }\n') + f.write('const struct rglgen_sym_map rglgen_symbol_map[] = {\n') + dump(f, macros) + f.write(' { NULL, NULL },\n') + f.write('};\n') + dump(f, declarations) diff --git a/src/libretro/libretro-common/glsym/xglgen.py b/src/libretro/libretro-common/glsym/xglgen.py new file mode 100644 index 00000000..215ffff3 --- /dev/null +++ b/src/libretro/libretro-common/glsym/xglgen.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 + +""" + License statement applies to this file (xglgen.py) only. + + Permission is hereby granted, free of charge, + to any person obtaining a copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation the rights to + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +""" + +import sys +import os +import re + +banned_ext = [ 'AMD', 'APPLE', 'NV', 'NVX', 'ATI', '3DLABS', 'SUN', 'SGI', 'SGIX', 'SGIS', 'INTEL', '3DFX', 'IBM', 'MESA', 'GREMEDY', 'OML', 'PGI', 'I3D', 'INGL', 'MTX', 'QCOM', 'IMG', 'ANGLE', 'SUNX', 'INGR' ] + +def noext(sym): + for ext in banned_ext: + if sym.endswith(ext): + return False + return True + +def fix_multiline_functions(lines): + fixed_lines = [] + temp_lines = [] + for line in lines: + if line.count('(') > line.count(')'): + temp_lines.append(line) + else: + if len(temp_lines) > 0: + if line.count(')') > line.count('('): + temp_lines.append(line) + fixed_line = re.sub(' +',' ', ''.join(temp_lines).replace('\n','').replace('\t','')) + fixed_lines.append(fixed_line) + temp_lines = [] + else: + temp_lines.append(line) + else: + fixed_lines.append(line) + return fixed_lines + +def find_gl_symbols(lines): + typedefs = [] + syms = [] + for line in lines: + # Note this doesn't work automated; this script is designed as a helper + m = re.search(r'^typedef.+PFN(\S+)PROC.+$', line) + g = re.search(r'^GLAPI\s(.+)\s(.+)\s(gl\S+)\W*\((.+)\).*', line) + if g and noext(g.group(3)): + typedefs.append('typedef ' + g.group(1) + ' (APIENTRYP RGLSYM' + g.group(3).upper() + 'PROC) (' + g.group(4) + ');') + syms.append(g.group(3)) + + return (typedefs, syms) + +def generate_defines(gl_syms): + res = [] + for line in gl_syms: + res.append('#define {} __rglgen_{}'.format(line, line)) + return res + +def generate_declarations(gl_syms): + return ['RGLSYM' + x.upper() + 'PROC ' + x + ';' for x in gl_syms] + +def generate_macros(gl_syms): + return [' SYM(' + x.replace('gl', '') + '),' for x in gl_syms] + +def dump(f, lines): + f.write('\n'.join(lines)) + f.write('\n\n') + +if __name__ == '__main__': + + if len(sys.argv) > 4: + for banned in sys.argv[4:]: + banned_ext.append(banned) + + with open(sys.argv[1], 'r') as f: + lines = fix_multiline_functions(f.readlines()) + typedefs, syms = find_gl_symbols(lines) + + overrides = generate_defines(syms) + declarations = generate_declarations(syms) + externs = ['extern ' + x for x in declarations] + + macros = generate_macros(syms) + + with open(sys.argv[2], 'w') as f: + f.write('#ifndef RGLGEN_DECL_H__\n') + f.write('#define RGLGEN_DECL_H__\n') + + f.write('#ifdef __cplusplus\n') + f.write('extern "C" {\n') + f.write('#endif\n') + + f.write('#ifdef GL_APIENTRY\n') + f.write('typedef void (GL_APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('typedef void (GL_APIENTRY *RGLGENGLDEBUGPROCKHR)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#else\n') + f.write('#ifndef APIENTRY\n') + f.write('#define APIENTRY\n') + f.write('#endif\n') + f.write('#ifndef APIENTRYP\n') + f.write('#define APIENTRYP APIENTRY *\n') + f.write('#endif\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROCARB)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('typedef void (APIENTRY *RGLGENGLDEBUGPROC)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, GLvoid*);\n') + f.write('#endif\n') + + f.write('#ifndef GL_OES_EGL_image\n') + f.write('typedef void *GLeglImageOES;\n') + f.write('#endif\n') + + f.write('#if !defined(GL_OES_fixed_point) && !defined(HAVE_OPENGLES2)\n') + f.write('typedef GLint GLfixed;\n') + f.write('#endif\n') + + f.write('#if defined(OSX) && !defined(MAC_OS_X_VERSION_10_7)\n') + f.write('typedef long long int GLint64;\n') + f.write('typedef unsigned long long int GLuint64;\n') + f.write('typedef unsigned long long int GLuint64EXT;\n') + f.write('typedef struct __GLsync *GLsync;\n') + f.write('#endif\n') + + dump(f, typedefs) + dump(f, overrides) + dump(f, externs) + + f.write('struct rglgen_sym_map { const char *sym; void *ptr; };\n') + f.write('extern const struct rglgen_sym_map rglgen_symbol_map[];\n') + + f.write('#ifdef __cplusplus\n') + f.write('}\n') + f.write('#endif\n') + + f.write('#endif\n') + + with open(sys.argv[3], 'w') as f: + f.write('#include "glsym/glsym.h"\n') + f.write('#include \n') + f.write('#define SYM(x) { "gl" #x, &(gl##x) }\n') + f.write('const struct rglgen_sym_map rglgen_symbol_map[] = {\n') + dump(f, macros) + f.write(' { NULL, NULL },\n') + f.write('};\n') + dump(f, declarations) diff --git a/src/libretro/libretro-common/include/array/rbuf.h b/src/libretro/libretro-common/include/array/rbuf.h new file mode 100644 index 00000000..deb045fb --- /dev/null +++ b/src/libretro/libretro-common/include/array/rbuf.h @@ -0,0 +1,120 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (rbuf.h). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __LIBRETRO_SDK_ARRAY_RBUF_H__ +#define __LIBRETRO_SDK_ARRAY_RBUF_H__ + +/* + * This file implements stretchy buffers as invented (?) by Sean Barrett. + * Based on the implementation from the public domain Bitwise project + * by Per Vognsen - https://github.com/pervognsen/bitwise + * + * It's a super simple type safe dynamic array for C with no need + * to predeclare any type or anything. + * The first time an element is added, memory for 16 elements are allocated. + * Then every time length is about to exceed capacity, capacity is doubled. + * + * Be careful not to supply modifying statements to the macro arguments. + * Something like RBUF_REMOVE(buf, i--); would have unintended results. + * + * Sample usage: + * + * mytype_t* buf = NULL; + * RBUF_PUSH(buf, some_element); + * RBUF_PUSH(buf, other_element); + * -- now RBUF_LEN(buf) == 2, buf[0] == some_element, buf[1] == other_element + * + * -- Free allocated memory: + * RBUF_FREE(buf); + * -- now buf == NULL, RBUF_LEN(buf) == 0, RBUF_CAP(buf) == 0 + * + * -- Explicitly increase allocated memory and set capacity: + * RBUF_FIT(buf, 100); + * -- now RBUF_LEN(buf) == 0, RBUF_CAP(buf) == 100 + * + * -- Resize buffer (does not initialize or zero memory!) + * RBUF_RESIZE(buf, 200); + * -- now RBUF_LEN(buf) == 200, RBUF_CAP(buf) == 200 + * + * -- To handle running out of memory: + * bool ran_out_of_memory = !RBUF_TRYFIT(buf, 1000); + * -- before RESIZE or PUSH. When out of memory, buf will stay unmodified. + */ + +#include /* for MAX */ +#include /* for malloc, realloc */ + +#define RBUF__HDR(b) (((struct rbuf__hdr *)(b))-1) + +#define RBUF_LEN(b) ((b) ? RBUF__HDR(b)->len : 0) +#define RBUF_CAP(b) ((b) ? RBUF__HDR(b)->cap : 0) +#define RBUF_END(b) ((b) + RBUF_LEN(b)) +#define RBUF_SIZEOF(b) ((b) ? RBUF_LEN(b)*sizeof(*b) : 0) + +#define RBUF_FREE(b) ((b) ? (free(RBUF__HDR(b)), (b) = NULL) : 0) +#define RBUF_FIT(b, n) ((size_t)(n) <= RBUF_CAP(b) ? 0 : (*(void**)(&(b)) = rbuf__grow((b), (n), sizeof(*(b))))) +#define RBUF_PUSH(b, val) (RBUF_FIT((b), 1 + RBUF_LEN(b)), (b)[RBUF__HDR(b)->len++] = (val)) +#define RBUF_POP(b) (b)[--RBUF__HDR(b)->len] +#define RBUF_RESIZE(b, sz) (RBUF_FIT((b), (sz)), ((b) ? RBUF__HDR(b)->len = (sz) : 0)) +#define RBUF_CLEAR(b) ((b) ? RBUF__HDR(b)->len = 0 : 0) +#define RBUF_TRYFIT(b, n) (RBUF_FIT((b), (n)), (((b) && RBUF_CAP(b) >= (size_t)(n)) || !(n))) +#define RBUF_REMOVE(b, idx) memmove((b) + (idx), (b) + (idx) + 1, (--RBUF__HDR(b)->len - (idx)) * sizeof(*(b))) + +struct rbuf__hdr +{ + size_t len; + size_t cap; +}; + +#ifdef __GNUC__ +__attribute__((__unused__)) +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4505) //unreferenced local function has been removed +#endif +static void *rbuf__grow(void *buf, + size_t new_len, size_t elem_size) +{ + struct rbuf__hdr *new_hdr; + size_t new_cap = MAX(2 * RBUF_CAP(buf), MAX(new_len, 16)); + size_t new_size = sizeof(struct rbuf__hdr) + new_cap*elem_size; + if (buf) + { + new_hdr = (struct rbuf__hdr *)realloc(RBUF__HDR(buf), new_size); + if (!new_hdr) + return buf; /* out of memory, return unchanged */ + } + else + { + new_hdr = (struct rbuf__hdr *)malloc(new_size); + if (!new_hdr) + return NULL; /* out of memory */ + new_hdr->len = 0; + } + new_hdr->cap = new_cap; + return new_hdr + 1; +} +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#endif diff --git a/src/libretro/libretro-common/include/array/rhmap.h b/src/libretro/libretro-common/include/array/rhmap.h new file mode 100644 index 00000000..d6aec901 --- /dev/null +++ b/src/libretro/libretro-common/include/array/rhmap.h @@ -0,0 +1,285 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (rhmap.h). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __LIBRETRO_SDK_ARRAY_RHMAP_H__ +#define __LIBRETRO_SDK_ARRAY_RHMAP_H__ + +/* + * This file implements a hash map with 32-bit keys. + * Based on the implementation from the public domain Bitwise project + * by Per Vognsen - https://github.com/pervognsen/bitwise + * + * It's a super simple type safe hash map for C with no need + * to predeclare any type or anything. + * Will always allocate memory for twice the amount of max elements + * so larger structs should be stored as pointers or indices to an array. + * Can be used in C++ with POD types (without any constructor/destructor). + * + * Be careful not to supply modifying statements to the macro arguments. + * Something like RHMAP_FIT(map, i++); would have unintended results. + * + * Sample usage: + * + * -- Set 2 elements with string keys and mytype_t values: + * mytype_t* map = NULL; + * RHMAP_SET_STR(map, "foo", foo_element); + * RHMAP_SET_STR(map, "bar", bar_element); + * -- now RHMAP_LEN(map) == 2, RHMAP_GET_STR(map, "foo") == foo_element + * + * -- Check if keys exist: + * bool has_foo = RHMAP_HAS_STR(map, "foo"); + * bool has_baz = RHMAP_HAS_STR(map, "baz"); + * -- now has_foo == true, has_baz == false + * + * -- Removing a key: + * bool removed = RHMAP_DEL_STR(map, "bar"); + * bool removed_again = RHMAP_DEL_STR(map, "bar"); + * -- now RHMAP_LEN(map) == 1, removed == true, removed_again == false + * + * -- Add/modify via pointer: + * mytype_t* p_elem = RHMAP_PTR_STR(map, "qux"); + * p_elem->a = 123; + * -- New keys initially have memory uninitialized + * -- Pointers can get invalidated when a key is added/removed + * + * -- Looking up the index for a given key: + * ptrdiff_t idx_foo = RHMAP_IDX_STR(map, "foo"); + * ptrdiff_t idx_invalid = RHMAP_IDX_STR(map, "invalid"); + * -- now idx_foo >= 0, idx_invalid == -1, map[idx_foo] == foo_element + * -- Indices can change when a key is added/removed + * + * -- Clear all elements (keep memory allocated): + * RHMAP_CLEAR(map); + * -- now RHMAP_LEN(map) == 0, RHMAP_CAP(map) == 16 + * + * -- Reserve memory for at least N elements: + * RHMAP_FIT(map, 30); + * -- now RHMAP_LEN(map) == 0, RHMAP_CAP(map) == 64 + * + * -- Add elements with custom hash keys: + * RHMAP_SET(map, my_uint32_hash(key1), some_element); + * RHMAP_SET(map, my_uint32_hash(key2), other_element); + * -- now RHMAP_LEN(map) == 2, _GET/_HAS/_DEL/_PTR/_IDX also exist + * + * -- Iterate elements (random order, order can change on insert): + * for (size_t i = 0, cap = RHMAP_CAP(map); i != cap, i++) + * if (RHMAP_KEY(map, i)) + * ------ here map[i] is the value of key RHMAP_KEY(map, i) + * + * -- Set a custom null value (is zeroed by default): + * RHMAP_SETNULLVAL(map, map_null); + * -- now RHMAP_GET_STR(map, "invalid") == map_null + * + * -- Free allocated memory: + * RHMAP_FREE(map); + * -- now map == NULL, RHMAP_LEN(map) == 0, RHMAP_CAP(map) == 0 + * + * -- To handle running out of memory: + * bool ran_out_of_memory = !RHMAP_TRYFIT(map, 1000); + * -- before setting an element (with SET, PTR or NULLVAL). + * -- When out of memory, map will stay unmodified. + * + */ + +#include /* for malloc, realloc */ +#include /* for memcpy, memset */ +#include /* for ptrdiff_t, size_t */ +#include /* for uint32_t */ + +#define RHMAP_LEN(b) ((b) ? RHMAP__HDR(b)->len : 0) +#define RHMAP_MAX(b) ((b) ? RHMAP__HDR(b)->maxlen : 0) +#define RHMAP_CAP(b) ((b) ? RHMAP__HDR(b)->maxlen + 1 : 0) +#define RHMAP_KEY(b, idx) (RHMAP__HDR(b)->keys[idx]) +#define RHMAP_KEY_STR(b, idx) (RHMAP__HDR(b)->key_strs[idx]) +#define RHMAP_SETNULLVAL(b, val) (RHMAP__FIT1(b), b[-1] = (val)) +#define RHMAP_CLEAR(b) ((b) ? (memset(RHMAP__HDR(b)->keys, 0, RHMAP_CAP(b) * sizeof(uint32_t)), RHMAP__HDR(b)->len = 0) : 0) +#define RHMAP_FREE(b) ((b) ? (rhmap__free(RHMAP__HDR(b)), (b) = NULL) : 0) +#define RHMAP_FIT(b, n) ((!(n) || ((b) && (size_t)(n) * 2 <= RHMAP_MAX(b))) ? 0 : RHMAP__GROW(b, n)) +#define RHMAP_TRYFIT(b, n) (RHMAP_FIT((b), (n)), (!(n) || ((b) && (size_t)(n) * 2 <= RHMAP_MAX(b)))) + +#define RHMAP_SET(b, key, val) RHMAP_SET_FULL(b, key, NULL, val) +#define RHMAP_GET(b, key) RHMAP_GET_FULL(b, key, NULL) +#define RHMAP_HAS(b, key) RHMAP_HAS_FULL(b, key, NULL) +#define RHMAP_DEL(b, key) RHMAP_DEL_FULL(b, key, NULL) +#define RHMAP_PTR(b, key) RHMAP_PTR_FULL(b, key, NULL) +#define RHMAP_IDX(b, key) RHMAP_IDX_FULL(b, key, NULL) + +#ifdef __GNUC__ +#define RHMAP__UNUSED __attribute__((__unused__)) +#else +#define RHMAP__UNUSED +#endif + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4505) //unreferenced local function has been removed +#endif + +#define RHMAP_SET_FULL(b, key, str, val) (RHMAP__FIT1(b), b[rhmap__idx(RHMAP__HDR(b), (key), (str), 1, 0)] = (val)) +#define RHMAP_GET_FULL(b, key, str) (RHMAP__FIT1(b), b[rhmap__idx(RHMAP__HDR(b), (key), (str), 0, 0)]) +#define RHMAP_HAS_FULL(b, key, str) ((b) ? rhmap__idx(RHMAP__HDR(b), (key), (str), 0, 0) != -1 : 0) +#define RHMAP_DEL_FULL(b, key, str) ((b) ? rhmap__idx(RHMAP__HDR(b), (key), (str), 0, sizeof(*(b))) != -1 : 0) +#define RHMAP_PTR_FULL(b, key, str) (RHMAP__FIT1(b), &b[rhmap__idx(RHMAP__HDR(b), (key), (str), 1, 0)]) +#define RHMAP_IDX_FULL(b, key, str) ((b) ? rhmap__idx(RHMAP__HDR(b), (key), (str), 0, 0) : -1) + +#define RHMAP_SET_STR(b, string_key, val) RHMAP_SET_FULL(b, rhmap_hash_string(string_key), string_key, val) +#define RHMAP_GET_STR(b, string_key) RHMAP_GET_FULL(b, rhmap_hash_string(string_key), string_key) +#define RHMAP_HAS_STR(b, string_key) RHMAP_HAS_FULL(b, rhmap_hash_string(string_key), string_key) +#define RHMAP_DEL_STR(b, string_key) RHMAP_DEL_FULL(b, rhmap_hash_string(string_key), string_key) +#define RHMAP_PTR_STR(b, string_key) RHMAP_PTR_FULL(b, rhmap_hash_string(string_key), string_key) +#define RHMAP_IDX_STR(b, string_key) RHMAP_IDX_FULL(b, rhmap_hash_string(string_key), string_key) + +RHMAP__UNUSED static uint32_t rhmap_hash_string(const char* str) +{ + unsigned char c; + uint32_t hash = (uint32_t)0x811c9dc5; + while ((c = (unsigned char)*(str++)) != '\0') + hash = ((hash * (uint32_t)0x01000193) ^ (uint32_t)c); + return (hash ? hash : 1); +} + +struct rhmap__hdr { size_t len, maxlen; uint32_t *keys; char** key_strs; }; +#define RHMAP__HDR(b) (((struct rhmap__hdr *)&(b)[-1])-1) +#define RHMAP__GROW(b, n) (*(void**)(&(b)) = rhmap__grow((void*)(b), sizeof(*(b)), (size_t)(n))) +#define RHMAP__FIT1(b) ((b) && RHMAP_LEN(b) * 2 <= RHMAP_MAX(b) ? 0 : RHMAP__GROW(b, 0)) + +RHMAP__UNUSED static void* rhmap__grow(void* old_ptr, size_t elem_size, size_t reserve) +{ + struct rhmap__hdr *old_hdr = (old_ptr ? ((struct rhmap__hdr *)((char*)old_ptr-elem_size))-1 : NULL); + struct rhmap__hdr *new_hdr; + char *new_vals; + size_t new_max = (old_ptr ? old_hdr->maxlen * 2 + 1 : 15); + for (; new_max / 2 <= reserve; new_max = new_max * 2 + 1) + if (new_max == (size_t)-1) + return old_ptr; /* overflow */ + + new_hdr = (struct rhmap__hdr *)malloc(sizeof(struct rhmap__hdr) + (new_max + 2) * elem_size); + if (!new_hdr) + return old_ptr; /* out of memory */ + + new_hdr->maxlen = new_max; + new_hdr->keys = (uint32_t *)calloc(new_max + 1, sizeof(uint32_t)); + if (!new_hdr->keys) + { + /* out of memory */ + free(new_hdr); + return old_ptr; + } + new_hdr->key_strs = (char**)calloc(new_max + 1, sizeof(char*)); + if (!new_hdr->key_strs) + { + /* out of memory */ + free(new_hdr->keys); + free(new_hdr); + return old_ptr; + } + + new_vals = ((char*)(new_hdr + 1)) + elem_size; + if (old_ptr) + { + size_t i; + char* old_vals = ((char*)(old_hdr + 1)) + elem_size; + for (i = 0; i <= old_hdr->maxlen; i++) + { + uint32_t key, j; + if (!old_hdr->keys[i]) + continue; + for (key = old_hdr->keys[i], j = key;; j++) + { + if (!new_hdr->keys[j &= new_hdr->maxlen]) + { + new_hdr->keys[j] = key; + new_hdr->key_strs[j] = old_hdr->key_strs[i]; + memcpy(new_vals + j * elem_size, old_vals + i * elem_size, elem_size); + break; + } + } + } + memcpy(new_vals - elem_size, old_vals - elem_size, elem_size); + new_hdr->len = old_hdr->len; + free(old_hdr->keys); + free(old_hdr->key_strs); + free(old_hdr); + } + else + { + memset(new_vals - elem_size, 0, elem_size); + new_hdr->len = 0; + } + return new_vals; +} + +RHMAP__UNUSED static ptrdiff_t rhmap__idx(struct rhmap__hdr* hdr, uint32_t key, const char * str, int add, size_t del) +{ + uint32_t i; + + if (!key) + return (ptrdiff_t)-1; + + for (i = key;; i++) + { + if (hdr->keys[i &= hdr->maxlen] == key && (!hdr->key_strs[i] || !str || !strcmp(hdr->key_strs[i], str))) + { + if (del) + { + hdr->len--; + hdr->keys[i] = 0; + free(hdr->key_strs[i]); + hdr->key_strs[i] = NULL; + while ((key = hdr->keys[i = (i + 1) & hdr->maxlen]) != 0) + { + if ((key = (uint32_t)rhmap__idx(hdr, key, hdr->key_strs[i], 1, 0)) == i) continue; + hdr->len--; + hdr->keys[i] = 0; + free(hdr->key_strs[i]); + hdr->key_strs[i] = NULL; + memcpy(((char*)(hdr + 1)) + (key + 1) * del, + ((char*)(hdr + 1)) + (i + 1) * del, del); + } + } + return (ptrdiff_t)i; + } + if (!hdr->keys[i]) + { + if (add) { hdr->len++; hdr->keys[i] = key; if (str) hdr->key_strs[i] = strdup(str); return (ptrdiff_t)i; } + return (ptrdiff_t)-1; + } + } +} + +RHMAP__UNUSED static void rhmap__free(struct rhmap__hdr* hdr) +{ + size_t i; + for (i=0;imaxlen+1;i++) + { + free(hdr->key_strs[i]); + } + free(hdr->key_strs); + free(hdr->keys); + free(hdr); +} + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#endif diff --git a/src/libretro/libretro-common/include/audio/audio_mix.h b/src/libretro/libretro-common/include/audio/audio_mix.h new file mode 100644 index 00000000..6a2adac1 --- /dev/null +++ b/src/libretro/libretro-common/include/audio/audio_mix.h @@ -0,0 +1,94 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (audio_mix.h). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __LIBRETRO_SDK_AUDIO_MIX_H__ +#define __LIBRETRO_SDK_AUDIO_MIX_H__ + +#include + +#include +#include +#ifdef _WIN32 +#include +#else +#include +#endif + +#include +#include