}
EGLint
-eglGetError(void)
+coregl_api_eglGetError(void)
{
INIT_EXPORT();
return ovr_eglGetError();
}
EGLDisplay
-eglGetDisplay(EGLNativeDisplayType display_id)
+coregl_api_eglGetDisplay(EGLNativeDisplayType display_id)
{
INIT_EXPORT();
return ovr_eglGetDisplay(display_id);
}
EGLBoolean
-eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
+coregl_api_eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
{
INIT_EXPORT();
return ovr_eglInitialize(dpy, major, minor);
}
EGLBoolean
-eglTerminate(EGLDisplay dpy)
+coregl_api_eglTerminate(EGLDisplay dpy)
{
INIT_EXPORT();
return ovr_eglTerminate(dpy);
}
EGLBoolean
-eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+coregl_api_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
INIT_EXPORT();
return ovr_eglGetConfigs(dpy, configs, config_size, num_config);
}
EGLBoolean
-eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
+coregl_api_eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
{
INIT_EXPORT();
return ovr_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
}
EGLBoolean
-eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
+coregl_api_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{
INIT_EXPORT();
return ovr_eglGetConfigAttrib(dpy, config, attribute, value);
EGLSurface
-eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
+coregl_api_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
{
INIT_EXPORT();
return ovr_eglCreateWindowSurface(dpy, config, win, attrib_list);
}
EGLSurface
-eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+coregl_api_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
INIT_EXPORT();
return ovr_eglCreatePbufferSurface(dpy, config, attrib_list);
}
EGLSurface
-eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
+coregl_api_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
{
INIT_EXPORT();
return ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
}
EGLBoolean
-eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
+coregl_api_eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{
INIT_EXPORT();
return ovr_eglDestroySurface(dpy, surface);
}
EGLBoolean
-eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
+coregl_api_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
INIT_EXPORT();
return ovr_eglQuerySurface(dpy, surface, attribute, value);
}
EGLBoolean
-eglBindAPI(EGLenum api)
+coregl_api_eglBindAPI(EGLenum api)
{
INIT_EXPORT();
return ovr_eglBindAPI(api);
}
EGLenum
-eglQueryAPI(void)
+coregl_api_eglQueryAPI(void)
{
INIT_EXPORT();
return ovr_eglQueryAPI();
}
EGLBoolean
-eglWaitClient(void)
+coregl_api_eglWaitClient(void)
{
INIT_EXPORT();
return ovr_eglWaitClient();
}
EGLBoolean
-eglReleaseThread(void)
+coregl_api_eglReleaseThread(void)
{
INIT_EXPORT();
return ovr_eglReleaseThread();
}
EGLSurface
-eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
+coregl_api_eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{
INIT_EXPORT();
return ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
}
EGLBoolean
-eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
+coregl_api_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
{
INIT_EXPORT();
return ovr_eglSurfaceAttrib(dpy, surface, attribute, value);
}
EGLBoolean
-eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+coregl_api_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
INIT_EXPORT();
return ovr_eglBindTexImage(dpy, surface, buffer);
}
EGLBoolean
-eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+coregl_api_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
INIT_EXPORT();
return ovr_eglReleaseTexImage(dpy, surface, buffer);
}
EGLBoolean
-eglSwapInterval(EGLDisplay dpy, EGLint interval)
+coregl_api_eglSwapInterval(EGLDisplay dpy, EGLint interval)
{
INIT_EXPORT();
return ovr_eglSwapInterval(dpy, interval);
}
EGLContext
-eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
+coregl_api_eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
{
INIT_EXPORT();
return ovr_eglCreateContext(dpy, config, share_context, attrib_list);
}
EGLBoolean
-eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
+coregl_api_eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
INIT_EXPORT();
return ovr_eglDestroyContext(dpy, ctx);
}
EGLBoolean
-eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+coregl_api_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
INIT_EXPORT();
return ovr_eglMakeCurrent(dpy, draw, read, ctx);
}
EGLContext
-eglGetCurrentContext(void)
+coregl_api_eglGetCurrentContext(void)
{
INIT_EXPORT();
return ovr_eglGetCurrentContext();
}
EGLSurface
-eglGetCurrentSurface(EGLint readdraw)
+coregl_api_eglGetCurrentSurface(EGLint readdraw)
{
INIT_EXPORT();
return ovr_eglGetCurrentSurface(readdraw);
}
EGLDisplay
-eglGetCurrentDisplay(void)
+coregl_api_eglGetCurrentDisplay(void)
{
INIT_EXPORT();
return ovr_eglGetCurrentDisplay();
}
EGLBoolean
-eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
+coregl_api_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{
INIT_EXPORT();
return ovr_eglQueryContext(dpy, ctx, attribute, value);
}
EGLBoolean
-eglWaitGL(void)
+coregl_api_eglWaitGL(void)
{
INIT_EXPORT();
return ovr_eglWaitGL();
}
EGLBoolean
-eglWaitNative(EGLint engine)
+coregl_api_eglWaitNative(EGLint engine)
{
INIT_EXPORT();
return ovr_eglWaitNative(engine);
}
EGLBoolean
-eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
+coregl_api_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{
INIT_EXPORT();
return ovr_eglSwapBuffers(dpy, surface);
}
EGLBoolean
-eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
+coregl_api_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
INIT_EXPORT();
return ovr_eglCopyBuffers(dpy, surface, target);
}
_eng_fn
-eglGetProcAddress(const char* procname)
+coregl_api_eglGetProcAddress(const char* procname)
{
INIT_EXPORT();
return ovr_eglGetProcAddress(procname);
}
const char *
-eglQueryString(EGLDisplay dpy, EGLint name)
+coregl_api_eglQueryString(EGLDisplay dpy, EGLint name)
{
INIT_EXPORT();
return ovr_eglQueryString(dpy, name);
}
-EGLImageKHR
-eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
-{
- INIT_EXPORT();
- return ovr_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
-}
-
-EGLBoolean
-eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
-{
- INIT_EXPORT();
- return ovr_eglDestroyImageKHR(dpy, image);
-}
-
-void *
-eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type, EGLint access_option)
-{
- INIT_EXPORT();
- return ovr_eglMapImageSEC(dpy, image, device_type, access_option);
-}
-
-EGLBoolean
-eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type)
-{
- INIT_EXPORT();
- return ovr_eglUnmapImageSEC(dpy, image, device_type);
-}
-
-EGLBoolean
-eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value)
-{
- INIT_EXPORT();
- return ovr_eglGetImageAttribSEC(dpy, image, attribute, value);
-}
-
-EGLBoolean
-eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
-{
- INIT_EXPORT();
- return ovr_eglLockSurfaceKHR(display, surface, attrib_list);
-}
-
-EGLBoolean
-eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
-{
- INIT_EXPORT();
- return ovr_eglUnlockSurfaceKHR(display, surface);
-}
-
#include "coregl_export.h"
void
-glActiveTexture(GLenum texture)
+coregl_api_glActiveTexture(GLenum texture)
{
ovr_glActiveTexture(texture);
}
void
-glAttachShader(GLuint program, GLuint shader)
+coregl_api_glAttachShader(GLuint program, GLuint shader)
{
ovr_glAttachShader(program, shader);
}
void
-glBindAttribLocation(GLuint program, GLuint index, const char* name)
+coregl_api_glBindAttribLocation(GLuint program, GLuint index, const char* name)
{
ovr_glBindAttribLocation(program, index, name);
}
void
-glBindBuffer(GLenum target, GLuint buffer)
+coregl_api_glBindBuffer(GLenum target, GLuint buffer)
{
ovr_glBindBuffer(target, buffer);
}
void
-glBindFramebuffer(GLenum target, GLuint framebuffer)
+coregl_api_glBindFramebuffer(GLenum target, GLuint framebuffer)
{
ovr_glBindFramebuffer(target, framebuffer);
}
void
-glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+coregl_api_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
ovr_glBindRenderbuffer(target, renderbuffer);
}
void
-glBindTexture(GLenum target, GLuint texture)
+coregl_api_glBindTexture(GLenum target, GLuint texture)
{
ovr_glBindTexture(target, texture);
}
void
-glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+coregl_api_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
ovr_glBlendColor(red, green, blue, alpha);
}
void
-glBlendEquation(GLenum mode)
+coregl_api_glBlendEquation(GLenum mode)
{
ovr_glBlendEquation(mode);
}
void
-glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+coregl_api_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
}
void
-glBlendFunc(GLenum sfactor, GLenum dfactor)
+coregl_api_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
ovr_glBlendFunc(sfactor, dfactor);
}
void
-glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+coregl_api_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void
-glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
+coregl_api_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
{
ovr_glBufferData(target, size, data, usage);
}
void
-glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
+coregl_api_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
{
ovr_glBufferSubData(target, offset, size, data);
}
GLenum
-glCheckFramebufferStatus(GLenum target)
+coregl_api_glCheckFramebufferStatus(GLenum target)
{
return ovr_glCheckFramebufferStatus(target);
}
void
-glClear(GLbitfield mask)
+coregl_api_glClear(GLbitfield mask)
{
ovr_glClear(mask);
}
void
-glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+coregl_api_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
ovr_glClearColor(red, green, blue, alpha);
}
void
-glClearDepthf(GLclampf depth)
+coregl_api_glClearDepthf(GLclampf depth)
{
ovr_glClearDepthf(depth);
}
void
-glClearStencil(GLint s)
+coregl_api_glClearStencil(GLint s)
{
ovr_glClearStencil(s);
}
void
-glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+coregl_api_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
ovr_glColorMask(red, green, blue, alpha);
}
void
-glCompileShader(GLuint shader)
+coregl_api_glCompileShader(GLuint shader)
{
ovr_glCompileShader(shader);
}
void
-glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
+coregl_api_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
{
ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void
-glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+coregl_api_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
{
ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void
-glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+coregl_api_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void
-glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+coregl_api_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
GLuint
-glCreateProgram(void)
+coregl_api_glCreateProgram(void)
{
return ovr_glCreateProgram();
}
GLuint
-glCreateShader(GLenum type)
+coregl_api_glCreateShader(GLenum type)
{
return ovr_glCreateShader(type);
}
void
-glCullFace(GLenum mode)
+coregl_api_glCullFace(GLenum mode)
{
ovr_glCullFace(mode);
}
void
-glDeleteBuffers(GLsizei n, const GLuint* buffers)
+coregl_api_glDeleteBuffers(GLsizei n, const GLuint* buffers)
{
ovr_glDeleteBuffers(n, buffers);
}
void
-glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+coregl_api_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
{
ovr_glDeleteFramebuffers(n, framebuffers);
}
void
-glDeleteProgram(GLuint program)
+coregl_api_glDeleteProgram(GLuint program)
{
ovr_glDeleteProgram(program);
}
void
-glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+coregl_api_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
ovr_glDeleteRenderbuffers(n, renderbuffers);
}
void
-glDeleteShader(GLuint shader)
+coregl_api_glDeleteShader(GLuint shader)
{
ovr_glDeleteShader(shader);
}
void
-glDeleteTextures(GLsizei n, const GLuint* textures)
+coregl_api_glDeleteTextures(GLsizei n, const GLuint* textures)
{
ovr_glDeleteTextures(n, textures);
}
void
-glDepthFunc(GLenum func)
+coregl_api_glDepthFunc(GLenum func)
{
ovr_glDepthFunc(func);
}
void
-glDepthMask(GLboolean flag)
+coregl_api_glDepthMask(GLboolean flag)
{
ovr_glDepthMask(flag);
}
void
-glDepthRangef(GLclampf zNear, GLclampf zFar)
+coregl_api_glDepthRangef(GLclampf zNear, GLclampf zFar)
{
ovr_glDepthRangef(zNear, zFar);
}
void
-glDetachShader(GLuint program, GLuint shader)
+coregl_api_glDetachShader(GLuint program, GLuint shader)
{
ovr_glDetachShader(program, shader);
}
void
-glDisable(GLenum cap)
+coregl_api_glDisable(GLenum cap)
{
ovr_glDisable(cap);
}
void
-glDisableVertexAttribArray(GLuint index)
+coregl_api_glDisableVertexAttribArray(GLuint index)
{
ovr_glDisableVertexAttribArray(index);
}
void
-glDrawArrays(GLenum mode, GLint first, GLsizei count)
+coregl_api_glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
ovr_glDrawArrays(mode, first, count);
}
void
-glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
+coregl_api_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
{
ovr_glDrawElements(mode, count, type, indices);
}
void
-glEnable(GLenum cap)
+coregl_api_glEnable(GLenum cap)
{
ovr_glEnable(cap);
}
void
-glEnableVertexAttribArray(GLuint index)
+coregl_api_glEnableVertexAttribArray(GLuint index)
{
ovr_glEnableVertexAttribArray(index);
}
void
-glFinish(void)
+coregl_api_glFinish(void)
{
ovr_glFinish();
}
void
-glFlush(void)
+coregl_api_glFlush(void)
{
ovr_glFlush();
}
void
-glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+coregl_api_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void
-glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+coregl_api_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void
-glFrontFace(GLenum mode)
+coregl_api_glFrontFace(GLenum mode)
{
ovr_glFrontFace(mode);
}
void
-glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+coregl_api_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
{
ovr_glGetVertexAttribfv(index, pname, params);
}
void
-glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+coregl_api_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
{
ovr_glGetVertexAttribiv(index, pname, params);
}
void
-glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
+coregl_api_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
{
ovr_glGetVertexAttribPointerv(index, pname, pointer);
}
void
-glHint(GLenum target, GLenum mode)
+coregl_api_glHint(GLenum target, GLenum mode)
{
ovr_glHint(target, mode);
}
void
-glGenBuffers(GLsizei n, GLuint* buffers)
+coregl_api_glGenBuffers(GLsizei n, GLuint* buffers)
{
ovr_glGenBuffers(n, buffers);
}
void
-glGenerateMipmap(GLenum target)
+coregl_api_glGenerateMipmap(GLenum target)
{
ovr_glGenerateMipmap(target);
}
void
-glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+coregl_api_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
{
ovr_glGenFramebuffers(n, framebuffers);
}
void
-glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+coregl_api_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
ovr_glGenRenderbuffers(n, renderbuffers);
}
void
-glGenTextures(GLsizei n, GLuint* textures)
+coregl_api_glGenTextures(GLsizei n, GLuint* textures)
{
ovr_glGenTextures(n, textures);
}
void
-glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+coregl_api_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
}
void
-glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+coregl_api_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
}
void
-glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+coregl_api_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
ovr_glGetAttachedShaders(program, maxcount, count, shaders);
}
int
-glGetAttribLocation(GLuint program, const char* name)
+coregl_api_glGetAttribLocation(GLuint program, const char* name)
{
return ovr_glGetAttribLocation(program, name);
}
void
-glGetBooleanv(GLenum pname, GLboolean* params)
+coregl_api_glGetBooleanv(GLenum pname, GLboolean* params)
{
ovr_glGetBooleanv(pname, params);
}
void
-glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+coregl_api_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
ovr_glGetBufferParameteriv(target, pname, params);
}
GLenum
-glGetError(void)
+coregl_api_glGetError(void)
{
return ovr_glGetError();
}
void
-glGetFloatv(GLenum pname, GLfloat* params)
+coregl_api_glGetFloatv(GLenum pname, GLfloat* params)
{
ovr_glGetFloatv(pname, params);
}
void
-glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+coregl_api_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
void
-glGetIntegerv(GLenum pname, GLint* params)
+coregl_api_glGetIntegerv(GLenum pname, GLint* params)
{
ovr_glGetIntegerv(pname, params);
}
void
-glGetProgramiv(GLuint program, GLenum pname, GLint* params)
+coregl_api_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
ovr_glGetProgramiv(program, pname, params);
}
void
-glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
+coregl_api_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
{
ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
}
void
-glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+coregl_api_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
ovr_glGetRenderbufferParameteriv(target, pname, params);
}
void
-glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+coregl_api_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
ovr_glGetShaderiv(shader, pname, params);
}
void
-glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+coregl_api_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
{
ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
}
void
-glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+coregl_api_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
void
-glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+coregl_api_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
{
ovr_glGetShaderSource(shader, bufsize, length, source);
}
const GLubyte *
-glGetString(GLenum name)
+coregl_api_glGetString(GLenum name)
{
return ovr_glGetString(name);
}
void
-glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+coregl_api_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
{
ovr_glGetTexParameterfv(target, pname, params);
}
void
-glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+coregl_api_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
{
ovr_glGetTexParameteriv(target, pname, params);
}
void
-glGetUniformfv(GLuint program, GLint location, GLfloat* params)
+coregl_api_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
ovr_glGetUniformfv(program, location, params);
}
void
-glGetUniformiv(GLuint program, GLint location, GLint* params)
+coregl_api_glGetUniformiv(GLuint program, GLint location, GLint* params)
{
ovr_glGetUniformiv(program, location, params);
}
int
-glGetUniformLocation(GLuint program, const char* name)
+coregl_api_glGetUniformLocation(GLuint program, const char* name)
{
return ovr_glGetUniformLocation(program, name);
}
GLboolean
-glIsBuffer(GLuint buffer)
+coregl_api_glIsBuffer(GLuint buffer)
{
return ovr_glIsBuffer(buffer);
}
GLboolean
-glIsEnabled(GLenum cap)
+coregl_api_glIsEnabled(GLenum cap)
{
return ovr_glIsEnabled(cap);
}
GLboolean
-glIsFramebuffer(GLuint framebuffer)
+coregl_api_glIsFramebuffer(GLuint framebuffer)
{
return ovr_glIsFramebuffer(framebuffer);
}
GLboolean
-glIsProgram(GLuint program)
+coregl_api_glIsProgram(GLuint program)
{
return ovr_glIsProgram(program);
}
GLboolean
-glIsRenderbuffer(GLuint renderbuffer)
+coregl_api_glIsRenderbuffer(GLuint renderbuffer)
{
return ovr_glIsRenderbuffer(renderbuffer);
}
GLboolean
-glIsShader(GLuint shader)
+coregl_api_glIsShader(GLuint shader)
{
return ovr_glIsShader(shader);
}
GLboolean
-glIsTexture(GLuint texture)
+coregl_api_glIsTexture(GLuint texture)
{
return ovr_glIsTexture(texture);
}
void
-glLineWidth(GLfloat width)
+coregl_api_glLineWidth(GLfloat width)
{
ovr_glLineWidth(width);
}
void
-glLinkProgram(GLuint program)
+coregl_api_glLinkProgram(GLuint program)
{
ovr_glLinkProgram(program);
}
void
-glPixelStorei(GLenum pname, GLint param)
+coregl_api_glPixelStorei(GLenum pname, GLint param)
{
ovr_glPixelStorei(pname, param);
}
void
-glPolygonOffset(GLfloat factor, GLfloat units)
+coregl_api_glPolygonOffset(GLfloat factor, GLfloat units)
{
ovr_glPolygonOffset(factor, units);
}
void
-glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+coregl_api_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
{
ovr_glReadPixels(x, y, width, height, format, type, pixels);
}
void
-glReleaseShaderCompiler(void)
+coregl_api_glReleaseShaderCompiler(void)
{
ovr_glReleaseShaderCompiler();
}
void
-glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+coregl_api_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
ovr_glRenderbufferStorage(target, internalformat, width, height);
}
void
-glSampleCoverage(GLclampf value, GLboolean invert)
+coregl_api_glSampleCoverage(GLclampf value, GLboolean invert)
{
ovr_glSampleCoverage(value, invert);
}
void
-glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+coregl_api_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glScissor(x, y, width, height);
}
void
-glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
+coregl_api_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
{
ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
}
void
-glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+coregl_api_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
{
ovr_glShaderSource(shader, count, string, length);
}
void
-glStencilFunc(GLenum func, GLint ref, GLuint mask)
+coregl_api_glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
ovr_glStencilFunc(func, ref, mask);
}
void
-glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+coregl_api_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
ovr_glStencilFuncSeparate(face, func, ref, mask);
}
void
-glStencilMask(GLuint mask)
+coregl_api_glStencilMask(GLuint mask)
{
ovr_glStencilMask(mask);
}
void
-glStencilMaskSeparate(GLenum face, GLuint mask)
+coregl_api_glStencilMaskSeparate(GLenum face, GLuint mask)
{
ovr_glStencilMaskSeparate(face, mask);
}
void
-glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+coregl_api_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
ovr_glStencilOp(fail, zfail, zpass);
}
void
-glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+coregl_api_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
ovr_glStencilOpSeparate(face, fail, zfail, zpass);
}
void
-glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
+coregl_api_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
{
ovr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
}
void
-glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+coregl_api_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
ovr_glTexParameterf(target, pname, param);
}
void
-glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+coregl_api_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
{
ovr_glTexParameterfv(target, pname, params);
}
void
-glTexParameteri(GLenum target, GLenum pname, GLint param)
+coregl_api_glTexParameteri(GLenum target, GLenum pname, GLint param)
{
ovr_glTexParameteri(target, pname, param);
}
void
-glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+coregl_api_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
{
ovr_glTexParameteriv(target, pname, params);
}
void
-glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
+coregl_api_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
{
ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
void
-glUniform1f(GLint location, GLfloat x)
+coregl_api_glUniform1f(GLint location, GLfloat x)
{
ovr_glUniform1f(location, x);
}
void
-glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+coregl_api_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
{
ovr_glUniform1fv(location, count, v);
}
void
-glUniform1i(GLint location, GLint x)
+coregl_api_glUniform1i(GLint location, GLint x)
{
ovr_glUniform1i(location, x);
}
void
-glUniform1iv(GLint location, GLsizei count, const GLint* v)
+coregl_api_glUniform1iv(GLint location, GLsizei count, const GLint* v)
{
ovr_glUniform1iv(location, count, v);
}
void
-glUniform2f(GLint location, GLfloat x, GLfloat y)
+coregl_api_glUniform2f(GLint location, GLfloat x, GLfloat y)
{
ovr_glUniform2f(location, x, y);
}
void
-glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
+coregl_api_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
{
ovr_glUniform2fv(location, count, v);
}
void
-glUniform2i(GLint location, GLint x, GLint y)
+coregl_api_glUniform2i(GLint location, GLint x, GLint y)
{
ovr_glUniform2i(location, x, y);
}
void
-glUniform2iv(GLint location, GLsizei count, const GLint* v)
+coregl_api_glUniform2iv(GLint location, GLsizei count, const GLint* v)
{
ovr_glUniform2iv(location, count, v);
}
void
-glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+coregl_api_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
ovr_glUniform3f(location, x, y, z);
}
void
-glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
+coregl_api_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
{
ovr_glUniform3fv(location, count, v);
}
void
-glUniform3i(GLint location, GLint x, GLint y, GLint z)
+coregl_api_glUniform3i(GLint location, GLint x, GLint y, GLint z)
{
ovr_glUniform3i(location, x, y, z);
}
void
-glUniform3iv(GLint location, GLsizei count, const GLint* v)
+coregl_api_glUniform3iv(GLint location, GLsizei count, const GLint* v)
{
ovr_glUniform3iv(location, count, v);
}
void
-glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+coregl_api_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
ovr_glUniform4f(location, x, y, z, w);
}
void
-glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
+coregl_api_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
{
ovr_glUniform4fv(location, count, v);
}
void
-glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+coregl_api_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
{
ovr_glUniform4i(location, x, y, z, w);
}
void
-glUniform4iv(GLint location, GLsizei count, const GLint* v)
+coregl_api_glUniform4iv(GLint location, GLsizei count, const GLint* v)
{
ovr_glUniform4iv(location, count, v);
}
void
-glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+coregl_api_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
ovr_glUniformMatrix2fv(location, count, transpose, value);
}
void
-glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+coregl_api_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
ovr_glUniformMatrix3fv(location, count, transpose, value);
}
void
-glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+coregl_api_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
ovr_glUniformMatrix4fv(location, count, transpose, value);
}
void
-glUseProgram(GLuint program)
+coregl_api_glUseProgram(GLuint program)
{
ovr_glUseProgram(program);
}
void
-glValidateProgram(GLuint program)
+coregl_api_glValidateProgram(GLuint program)
{
ovr_glValidateProgram(program);
}
void
-glVertexAttrib1f(GLuint indx, GLfloat x)
+coregl_api_glVertexAttrib1f(GLuint indx, GLfloat x)
{
ovr_glVertexAttrib1f(indx, x);
}
void
-glVertexAttrib1fv(GLuint indx, const GLfloat* values)
+coregl_api_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
{
ovr_glVertexAttrib1fv(indx, values);
}
void
-glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+coregl_api_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
{
ovr_glVertexAttrib2f(indx, x, y);
}
void
-glVertexAttrib2fv(GLuint indx, const GLfloat* values)
+coregl_api_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
{
ovr_glVertexAttrib2fv(indx, values);
}
void
-glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+coregl_api_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
{
ovr_glVertexAttrib3f(indx, x, y, z);
}
void
-glVertexAttrib3fv(GLuint indx, const GLfloat* values)
+coregl_api_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
{
ovr_glVertexAttrib3fv(indx, values);
}
void
-glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+coregl_api_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
ovr_glVertexAttrib4f(indx, x, y, z, w);
}
void
-glVertexAttrib4fv(GLuint indx, const GLfloat* values)
+coregl_api_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
{
ovr_glVertexAttrib4fv(indx, values);
}
void
-glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
+coregl_api_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
{
ovr_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
}
void
-glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+coregl_api_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glViewport(x, y, width, height);
}
projects / platform / core / uifw / coregl.git / commitdiff