X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=deps%2Flibretro-common%2Finclude%2Fglsm%2Fglsmsym.h;fp=deps%2Flibretro-common%2Finclude%2Fglsm%2Fglsmsym.h;h=3c9d3bd9a63fd7b4af264813e7688a32002b542a;hb=3719602cbe883fb394a71353e20a10a4a306e814;hp=0000000000000000000000000000000000000000;hpb=8659d7fd2cdb11f63724ead0997f47f4c694f8c2;p=pcsx_rearmed.git diff --git a/deps/libretro-common/include/glsm/glsmsym.h b/deps/libretro-common/include/glsm/glsmsym.h new file mode 100644 index 00000000..3c9d3bd9 --- /dev/null +++ b/deps/libretro-common/include/glsm/glsmsym.h @@ -0,0 +1,483 @@ +/* Copyright (C) 2010-2018 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 + +#ifdef HAVE_GLSYM_PRIVATE +#include "glsym_private.h" +#endif + +#include + +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 + +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 **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 **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, 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); +void *rglFenceSync(GLenum condition, GLbitfield flags); +void rglDeleteSync(void *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(void *sync, GLbitfield flags, uint64_t 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, GLvoid *indices, GLint basevertex); + +RETRO_END_DECLS + +#endif