text: /* Copyright (C) 2010-2019 The RetroArch team
   *
   * ---------------------------------------------------------------------------------------
   * The following license statement only applies to this libretro SDK code part (glsmsym.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_GLSM_SYM_H
  #define LIBRETRO_SDK_GLSM_SYM_H
  
  #include <glsm/glsm.h>
  
  #ifdef HAVE_GLSYM_PRIVATE
  #include "glsym_private.h"
  #endif
  
  #include <retro_common_api.h>
  
  RETRO_BEGIN_DECLS
  
  /* deprecated old FF-style GL symbols */
  #define glTexCoord2f                rglTexCoord2f
  
  /* more forward-compatible GL subset symbols */
  #define glDrawRangeElementsBaseVertex rglDrawRangeElementsBaseVertex
  #define glProvokingVertex           rglProvokingVertex
  #define glGetInteger64v             rglGetInteger64v
  #define glGenSamplers               rglGenSamplers
  #define glBindSampler               rglBindSampler
  #define glSamplerParameteri         rglSamplerParameteri
  #define glGetBufferSubData          rglGetBufferSubData
  #define glUniform2iv                rglUniform2iv
  #define glUniform2uiv               rglUniform2uiv
  #define glTextureView               rglTextureView
  #define glGetQueryObjectuiv         rglGetQueryObjectuiv
  #define glGenQueries                rglGenQueries
  #define glDeleteQueries             rglDeleteQueries
  #define glBeginQuery                rglBeginQuery
  #define glEndQuery                  rglEndQuery
  #define glBlitFramebuffer           rglBlitFramebuffer
  #define glVertexAttrib4f            rglVertexAttrib4f
  #define glVertexAttrib4fv           rglVertexAttrib4fv
  #define glDrawArrays                rglDrawArrays
  #define glDrawElements              rglDrawElements
  #define glCompressedTexImage2D      rglCompressedTexImage2D
  #define glBindTexture               rglBindTexture
  #define glActiveTexture             rglActiveTexture
  #define glFramebufferTexture        rglFramebufferTexture
  #define glFramebufferTexture2D      rglFramebufferTexture2D
  #define glFramebufferRenderbuffer   rglFramebufferRenderbuffer
  #define glDeleteFramebuffers        rglDeleteFramebuffers
  #define glDeleteTextures            rglDeleteTextures
  #define glDeleteBuffers             rglDeleteBuffers
  #define glRenderbufferStorage       rglRenderbufferStorage
  #define glBindRenderbuffer          rglBindRenderbuffer
  #define glDeleteRenderbuffers       rglDeleteRenderbuffers
  #define glGenRenderbuffers          rglGenRenderbuffers
  #define glGenFramebuffers           rglGenFramebuffers
  #define glGenTextures               rglGenTextures
  #define glBindFramebuffer           rglBindFramebuffer
  #define glGenerateMipmap            rglGenerateMipmap
  #define glCheckFramebufferStatus    rglCheckFramebufferStatus
  #define glBindFragDataLocation      rglBindFragDataLocation
  #define glBindAttribLocation        rglBindAttribLocation
  #define glLinkProgram               rglLinkProgram
  #define glGetProgramiv              rglGetProgramiv
  #define glGetShaderiv               rglGetShaderiv
  #define glAttachShader              rglAttachShader
  #define glDetachShader              rglDetachShader
  #define glShaderSource              rglShaderSource
  #define glCompileShader             rglCompileShader
  #define glCreateProgram             rglCreateProgram
  #define glGetShaderInfoLog          rglGetShaderInfoLog
  #define glGetProgramInfoLog         rglGetProgramInfoLog
  #define glIsProgram                 rglIsProgram
  #define glEnableVertexAttribArray   rglEnableVertexAttribArray
  #define glDisableVertexAttribArray  rglDisableVertexAttribArray
  #define glVertexAttribPointer       rglVertexAttribPointer
  #define glVertexAttribIPointer      rglVertexAttribIPointer
  #define glVertexAttribLPointer      rglVertexAttribLPointer
  #define glGetUniformLocation        rglGetUniformLocation
  #define glGenBuffers                rglGenBuffers
  #define glDisable(T)                rglDisable(S##T)
  #define glEnable(T)                 rglEnable(S##T)
  #define glIsEnabled(T)              rglIsEnabled(S##T)
  #define glUseProgram                rglUseProgram
  #define glDepthMask                 rglDepthMask
  #define glStencilMask               rglStencilMask
  #define glBufferData                rglBufferData
  #define glBufferSubData             rglBufferSubData
  #define glBindBuffer                rglBindBuffer
  #define glCreateShader              rglCreateShader
  #define glDeleteShader              rglDeleteShader
  #define glDeleteProgram             rglDeleteProgram
  #define glUniform1f                 rglUniform1f
  #define glUniform1i                 rglUniform1i
  #define glUniform2f                 rglUniform2f
  #define glUniform2i                 rglUniform2i
  #define glUniform2fv                rglUniform2fv
  #define glUniform3f                 rglUniform3f
  #define glUniform3fv                rglUniform3fv
  #define glUniform4i                 rglUniform4i
  #define glUniform4f                 rglUniform4f
  #define glUniform4fv                rglUniform4fv
  #define glUniform1ui                rglUniform1ui
  #define glUniform2ui                rglUniform2ui
  #define glUniform3ui                rglUniform3ui
  #define glUniform4ui                rglUniform4ui
  #define glGetActiveUniform          rglGetActiveUniform
  #define glBlendFunc                 rglBlendFunc
  #define glBlendFuncSeparate         rglBlendFuncSeparate
  #define glDepthFunc                 rglDepthFunc
  #define glColorMask                 rglColorMask
  #define glClearColor                rglClearColor
  #define glViewport                  rglViewport
  #define glScissor                   rglScissor
  #define glStencilFunc               rglStencilFunc
  #define glCullFace                  rglCullFace
  #define glStencilOp                 rglStencilOp
  #define glFrontFace                 rglFrontFace
  #define glDepthRange                rglDepthRange
  #define glClearDepth                rglClearDepth
  #define glPolygonOffset             rglPolygonOffset
  #define glPixelStorei               rglPixelStorei
  #define glReadBuffer                rglReadBuffer
  #define glUniformMatrix4fv          rglUniformMatrix4fv
  #define glGetAttribLocation         rglGetAttribLocation
  #define glTexStorage2D              rglTexStorage2D
  #define glDrawBuffers               rglDrawBuffers
  #define glGenVertexArrays           rglGenVertexArrays
  #define glBindVertexArray           rglBindVertexArray
  #define glBlendEquation             rglBlendEquation
  #define glBlendColor                rglBlendColor
  #define glBlendEquationSeparate     rglBlendEquationSeparate
  #define glCopyImageSubData          rglCopyImageSubData
  #define glMapBuffer                 rglMapBuffer
  #define glUnmapBuffer               rglUnmapBuffer
  #define glMapBufferRange            rglMapBufferRange
  #define glUniformBlockBinding       rglUniformBlockBinding
  #define glGetUniformBlockIndex      rglGetUniformBlockIndex
  #define glGetActiveUniformBlockiv   rglGetActiveUniformBlockiv
  #define glBindBufferBase            rglBindBufferBase
  #define glGetUniformIndices         rglGetUniformIndices
  #define glGetActiveUniformsiv       rglGetActiveUniformsiv
  #define glGetError                  rglGetError
  #define glClear                     rglClear
  #define glPolygonMode               rglPolygonMode
  #define glLineWidth                 rglLineWidth
  #define glTexImage3D                rglTexImage3D
  #define glTexImage2DMultisample     rglTexImage2DMultisample
  #define glTexStorage2DMultisample   rglTexStorage2DMultisample
  #define glMemoryBarrier             rglMemoryBarrier
  #define glBindImageTexture          rglBindImageTexture
  #define glProgramBinary             rglProgramBinary
  #define glGetProgramBinary          rglGetProgramBinary
  #define glProgramParameteri         rglProgramParameteri
  #define glTexSubImage2D             rglTexSubImage2D
  #define glDeleteVertexArrays        rglDeleteVertexArrays
  #define glRenderbufferStorageMultisample rglRenderbufferStorageMultisample
  #define glUniform1iv                rglUniform1iv
  #define glUniform1fv                rglUniform1fv
  #define glValidateProgram           rglValidateProgram
  #define glGetStringi                rglGetStringi
  #define glTexBuffer                 rglTexBuffer
  #define glClearBufferfv             rglClearBufferfv
  #define glClearBufferfi             rglClearBufferfi
  #define glWaitSync                  rglWaitSync
  #define glFenceSync                 rglFenceSync
  #define glDeleteSync                rglDeleteSync
  #define glBufferStorage             rglBufferStorage
  #define glFlushMappedBufferRange    rglFlushMappedBufferRange
  #define glClientWaitSync            rglClientWaitSync
  #define glDrawElementsBaseVertex    rglDrawElementsBaseVertex
  #define glReadPixels                rglReadPixels
  
  void rglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data);
  const GLubyte* rglGetStringi(GLenum name, GLuint index);
  void rglTexBuffer(GLenum target, GLenum internalFormat, GLuint buffer);
  void rglClearBufferfv( 	GLenum buffer,
    	GLint drawBuffer,
    	const GLfloat * value);
  void rglClearBufferfi( 	GLenum buffer,
    	GLint drawBuffer,
    	GLfloat depth,
    	GLint stencil);
  void rglValidateProgram(GLuint program);
  void rglRenderbufferStorageMultisample( 	GLenum target,
    	GLsizei samples,
    	GLenum internalformat,
    	GLsizei width,
    	GLsizei height);
  void rglUniform1iv(GLint location,  GLsizei count,  const GLint *value);
  void rglUniform1fv(GLint location,  GLsizei count,  const GLfloat *value);
  void rglProgramParameteri( 	GLuint program,
    	GLenum pname,
    	GLint value);
  void rglGetProgramBinary( 	GLuint program,
    	GLsizei bufsize,
    	GLsizei *length,
    	GLenum *binaryFormat,
    	void *binary);
  void rglProgramBinary(GLuint program,
    	GLenum binaryFormat,
    	const void *binary,
    	GLsizei length);
  void rglBindImageTexture( 	GLuint unit,
    	GLuint texture,
    	GLint level,
    	GLboolean layered,
    	GLint layer,
    	GLenum access,
    	GLenum format);
  void rglTexStorage2DMultisample(GLenum target, GLsizei samples,
        GLenum internalformat, GLsizei width, GLsizei height,
        GLboolean fixedsamplelocations);
  void rglGetActiveUniformsiv( 	GLuint program,
    	GLsizei uniformCount,
    	const GLuint *uniformIndices,
    	GLenum pname,
    	GLint *params);
  void rglGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
  void rglBindBufferBase( 	GLenum target,
    	GLuint index,
    	GLuint buffer);
  void rglGetActiveUniformBlockiv( 	GLuint program,
    	GLuint uniformBlockIndex,
    	GLenum pname,
    	GLint *params);
  GLuint rglGetUniformBlockIndex( 	GLuint program,
    	const GLchar *uniformBlockName);
  void * rglMapBuffer(	GLenum target, GLenum access);
  void *rglMapBufferRange( 	GLenum target,
    	GLintptr offset,
    	GLsizeiptr length,
    	GLbitfield access);
  GLboolean rglUnmapBuffer( 	GLenum target);
  void rglBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  void rglBlendEquation(GLenum mode);
  void rglGenVertexArrays(GLsizei n, GLuint *arrays);
  void rglReadBuffer(GLenum mode);
  void rglPixelStorei(GLenum pname, GLint param);
  void rglTexCoord2f(GLfloat s, GLfloat t);
  void rglDrawElements(GLenum mode, GLsizei count, GLenum type,
                             const GLvoid * indices);
  void rglTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat,
        GLsizei width, GLsizei height);
  void rglCompressedTexImage2D(GLenum target, GLint level,
        GLenum internalformat, GLsizei width, GLsizei height,
        GLint border, GLsizei imageSize, const GLvoid *data);
  void glBindTexture(GLenum target, GLuint texture);
  void glActiveTexture(GLenum texture);
  void rglFramebufferTexture(GLenum target, GLenum attachment,
    	GLuint texture, GLint level);
  void rglFramebufferTexture2D(GLenum target, GLenum attachment,
        GLenum textarget, GLuint texture, GLint level);
  void rglFramebufferRenderbuffer(GLenum target, GLenum attachment,
        GLenum renderbuffertarget, GLuint renderbuffer);
  void rglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
  void rglRenderbufferStorage(GLenum target, GLenum internalFormat,
        GLsizei width, GLsizei height);
  void rglDeleteTextures(GLsizei n, const GLuint *textures);
  void rglBindRenderbuffer(GLenum target, GLuint renderbuffer);
  void rglDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers);
  void rglGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
  void rglGenFramebuffers(GLsizei n, GLuint *ids);
  void rglGenTextures(GLsizei n, GLuint *textures);
  void rglBindFramebuffer(GLenum target, GLuint framebuffer);
  void rglGenerateMipmap(GLenum target);
  GLenum rglCheckFramebufferStatus(GLenum target);
  void rglBindFragDataLocation(GLuint program, GLuint colorNumber,
                                     const char * name);
  void rglBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
  void rglLinkProgram(GLuint program);
  void rglGetProgramiv(GLuint shader, GLenum pname, GLint *params);
  void rglGetShaderiv(GLuint shader, GLenum pname, GLint *params);
  void rglAttachShader(GLuint program, GLuint shader);
  void rglShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
  
  void rglCompileShader(GLuint shader);
  GLuint rglCreateProgram(void);
  void rglGetShaderInfoLog(GLuint shader, GLsizei maxLength,
        GLsizei *length, GLchar *infoLog);
  void rglGetProgramInfoLog(GLuint shader, GLsizei maxLength,
        GLsizei *length, GLchar *infoLog);
  GLboolean rglIsProgram(GLuint program);
  void rglEnableVertexAttribArray(GLuint index);
  void rglDisableVertexAttribArray(GLuint index);
  void rglVertexAttribPointer(GLuint name, GLint size,
        GLenum type, GLboolean normalized, GLsizei stride,
        const GLvoid* pointer);
  GLint rglGetUniformLocation(GLuint program, const GLchar *name);
  void rglGenBuffers(GLsizei n, GLuint *buffers);
  void rglDisable(GLenum cap);
  void rglEnable(GLenum cap);
  void rglUseProgram(GLuint program);
  void rglDepthMask(GLboolean flag);
  void rglStencilMask(GLenum mask);
  void rglBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
  void rglBufferSubData(GLenum target, GLintptr offset,
        GLsizeiptr size, const GLvoid *data);
  void rglBindBuffer(GLenum target, GLuint buffer);
  GLuint rglCreateShader(GLenum shader);
  void rglDeleteShader(GLuint shader);
  void rglUniform1f(GLint location, GLfloat v0);
  void rglUniform1i(GLint location, GLint v0);
  void rglUniform2f(GLint location, GLfloat v0, GLfloat v1);
  void rglUniform2i(GLint location, GLint v0, GLint v1);
  void rglUniform2fv(GLint location, GLsizei count, const GLfloat *value);
  void rglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
  void rglUniform3fv(GLint location, GLsizei count, const GLfloat *value);
  void rglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
  void rglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
  void rglUniform4fv(GLint location, GLsizei count, const GLfloat *value);
  void rglBlendFunc(GLenum sfactor, GLenum dfactor);
  void rglBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
        GLenum dstAlpha);
  void rglDepthFunc(GLenum func);
  void rglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
  void rglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  void rglViewport(GLint x, GLint y, GLsizei width, GLsizei height);
  void rglScissor(GLint x, GLint y, GLsizei width, GLsizei height);
  GLboolean rglIsEnabled(GLenum cap);
  void rglStencilFunc(GLenum func, GLint ref, GLuint mask);
  void rglCullFace(GLenum mode);
  void rglStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass);
  void rglFrontFace(GLenum mode);
  void rglDepthRange(GLclampd zNear, GLclampd zFar);
  void rglClearDepth(GLdouble depth);
  void rglPolygonOffset(GLfloat factor, GLfloat units);
  void rglDrawArrays(GLenum mode, GLint first, GLsizei count);
  void rglVertexAttrib4f(GLuint name, GLfloat x, GLfloat y,
        GLfloat z, GLfloat w);
  void rglVertexAttrib4fv(GLuint name, const GLfloat* v);
  void rglDeleteProgram(GLuint program);
  void rglDeleteBuffers(GLsizei n, const GLuint *buffers);
  void rglUniform2uiv(	GLint location,
   	GLsizei count,
   	const GLuint *value);
  void rglTextureView(	GLuint texture,
   	GLenum target,
   	GLuint origtexture,
   	GLenum internalformat,
   	GLuint minlevel,
   	GLuint numlevels,
   	GLuint minlayer,
   	GLuint numlayers);
  void rglGenQueries(	GLsizei n,
   	GLuint * ids);
  void rglDeleteQueries(	GLsizei n,
   	const GLuint * ids);
  void rglBeginQuery(	GLenum target,
   	GLuint id);
  void rglEndQuery(	GLenum target);
  void rglGetQueryObjectuiv(	GLuint id,
   	GLenum pname,
   	GLuint * params);
  void rglBlitFramebuffer(
        GLint srcX0, GLint srcY0,
        GLint srcX1, GLint srcY1,
        GLint dstX0, GLint dstY0,
        GLint dstX1, GLint dstY1,
        GLbitfield mask, GLenum filter);
  void rglDetachShader(GLuint program, GLuint shader);
  void rglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
        const GLfloat *value);
  GLint rglGetAttribLocation(GLuint program, const GLchar *name);
  void rglDrawBuffers(GLsizei n, const GLenum *bufs);
  void rglBindVertexArray(GLuint array);
  
  void rglGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
        GLsizei *length, GLint *size, GLenum *type, GLchar *name);
  void rglUniform1ui(GLint location, GLuint v);
  void rglUniform2ui(GLint location, GLuint v0, GLuint v1);
  void rglUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
  void rglUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
  void rglBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
  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);
  void rglVertexAttribIPointer(
        GLuint index,
        GLint size,
        GLenum type,
        GLsizei stride,
        const GLvoid * pointer);
  void rglVertexAttribLPointer(
        GLuint index,
        GLint size,
        GLenum type,
        GLsizei stride,
        const GLvoid * pointer);
  void rglUniformBlockBinding( 	GLuint program,
    	GLuint uniformBlockIndex,
    	GLuint uniformBlockBinding);
  GLenum rglGetError(void);
  void rglClear(GLbitfield mask);
  void rglPolygonMode(GLenum face, GLenum mode);
  void rglLineWidth(GLfloat width);
  void rglTexImage3D(	GLenum target,
   	GLint level,
   	GLint internalFormat,
   	GLsizei width,
   	GLsizei height,
   	GLsizei depth,
   	GLint border,
   	GLenum format,
   	GLenum type,
   	const GLvoid * data);
  void rglTexImage2DMultisample( 	GLenum target,
    	GLsizei samples,
    	GLenum internalformat,
    	GLsizei width,
    	GLsizei height,
    	GLboolean fixedsamplelocations);
  void rglMemoryBarrier( 	GLbitfield barriers);
  void rglTexSubImage2D( 	GLenum target,
    	GLint level,
    	GLint xoffset,
    	GLint yoffset,
    	GLsizei width,
    	GLsizei height,
    	GLenum format,
    	GLenum type,
    	const GLvoid * pixels);
  void rglDeleteVertexArrays(GLsizei n, const GLuint *arrays);
  GLsync rglFenceSync(GLenum condition, GLbitfield flags);
  void rglDeleteSync(GLsync sync);
  void rglWaitSync(void *sync, GLbitfield flags, uint64_t timeout);
  void rglBufferStorage(GLenum target, GLsizeiptr size, const GLvoid *data, GLbitfield flags);
  void rglFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
  GLenum rglClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
  void rglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
  			       GLvoid *indices, GLint basevertex);
  void rglGetBufferSubData(	GLenum target,
   	GLintptr offset,
   	GLsizeiptr size,
   	GLvoid * data);
  void rglSamplerParameteri(	GLuint sampler,
   	GLenum pname,
   	GLint param);
  void rglBindSampler(	GLuint unit,
   	GLuint sampler);
  void rglGenSamplers(	GLsizei n,
   	GLuint *samplers);
  void rglGetInteger64v(	GLenum pname,
   	int64_t * data);
  void rglUniform2iv(	GLint location,
   	GLsizei count,
   	const GLint *value);
  void rglProvokingVertex(	GLenum provokeMode);
  void rglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
  
  RETRO_END_DECLS
  
  #endif
  