--- /dev/null
+Apply coding style with astyle
+
+1. To apply coregl coding style to .c code, run this command:
+ astyle -A4 -t4 -xT4 -p -z2 -H -k3 -W3 -xC80 -xL -n -r "./*.c"
+
+2. To apply coregl coding style to .h code, run this command:
+ astyle -A4 -t4 -xT4 -p -z2 -H -k3 -W3 -xC80 -xL -n -r "./*.h"
+
+ notice: do not apply this command to khronos headers: ex. sub-directory of include_KHR/
if (!egl_lib_handle) {
COREGL_ERR("\E[40;31;1m%s\E[0m\n\n", dlerror());
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_EGL_LIB_PATH);
+ _COREGL_VENDOR_EGL_LIB_PATH);
return 0;
}
// test for invalid linking egl
if (dlsym(egl_lib_handle, "coregl_symbol_exported")) {
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_EGL_LIB_PATH);
+ _COREGL_VENDOR_EGL_LIB_PATH);
return 0;
}
// use gl_lib handle for GL symbols
if (driver_gl_version == COREGL_GLAPI_1) {
gl_lib_handle = dlopen(_COREGL_VENDOR_GLV1_LIB_PATH, RTLD_LAZY | RTLD_LOCAL);
- if(!gl_lib_handle) {
+ if (!gl_lib_handle) {
COREGL_ERR("\E[40;31;1m%s\E[0m\n\n", dlerror());
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_GLV1_LIB_PATH);
- }
- else {
+ _COREGL_VENDOR_GLV1_LIB_PATH);
+ } else {
// test for invalid linking gl
if (dlsym(gl_lib_handle, "coregl_symbol_exported")) {
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_GLV1_LIB_PATH);
+ _COREGL_VENDOR_GLV1_LIB_PATH);
return 0;
}
COREGL_LOG("[CoreGL] Driver GL version 1.1 \n");
}
- }
- else if (driver_gl_version == COREGL_GLAPI_2) {
+ } else if (driver_gl_version == COREGL_GLAPI_2) {
gl_lib_handle = dlopen(_COREGL_VENDOR_GLV2_LIB_PATH, RTLD_LAZY | RTLD_LOCAL);
if (!gl_lib_handle) {
COREGL_ERR("\E[40;31;1m%s\E[0m\n\n", dlerror());
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_GLV2_LIB_PATH);
- }
- else {
+ _COREGL_VENDOR_GLV2_LIB_PATH);
+ } else {
// test for invalid linking gl
if (dlsym(gl_lib_handle, "coregl_symbol_exported")) {
COREGL_ERR("\E[40;31;1mInvalid library link! (Check linkage of libCOREGL -> %s)\E[0m\n",
- _COREGL_VENDOR_GLV2_LIB_PATH);
+ _COREGL_VENDOR_GLV2_LIB_PATH);
return 0;
}
if (dlsym(gl_lib_handle, "glBlendBarrier")) {
COREGL_LOG("[CoreGL] Driver GL version 3.2 \n");
driver_gl_version = COREGL_GLAPI_32;
- }else if (dlsym(gl_lib_handle, "glBindProgramPipeline")) {
+ } else if (dlsym(gl_lib_handle, "glBindProgramPipeline")) {
COREGL_LOG("[CoreGL] Driver GL version 3.1 \n");
driver_gl_version = COREGL_GLAPI_31;
} else if (dlsym(gl_lib_handle, "glReadBuffer")) {
coregl_initialize()
{
COREGL_LOG("[CoreGL] <%d> (%s) Library initializing...", getpid(),
- _COREGL_COMPILE_DATE);
+ _COREGL_COMPILE_DATE);
if (!_gl_lib_init()) return 0;
COREGL_OVERRIDE_API(ovr_, f, _sym_)
#define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) OVERRIDE(FUNC_NAME);
- if(init_egl == GL_TRUE) {
- # include "headers/sym_egl.h"
+ if (init_egl == GL_TRUE) {
+# include "headers/sym_egl.h"
}
#undef _COREGL_SYMBOL
#undef OVERRIDE
#define OVERRIDE(f) \
if(api_gl_version<=driver_gl_version) COREGL_OVERRIDE_API(ovr_, f, _sym_)
#define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) OVERRIDE(FUNC_NAME);
- if(init_gl == GL_TRUE) {
- #include "headers/sym_gl1.h"
- #include "headers/sym_gl2.h"
- #include "headers/sym_gl_common.h"
+ if (init_gl == GL_TRUE) {
+#include "headers/sym_gl1.h"
+#include "headers/sym_gl2.h"
+#include "headers/sym_gl_common.h"
}
#undef _COREGL_SYMBOL
#undef OVERRIDE
EGLBoolean
coregl_api_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
- EGLint *num_config)
+ EGLint *num_config)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
- EGLConfig *configs, EGLint config_size, EGLint *num_config)
+ EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
- EGLint attribute, EGLint *value)
+ EGLint attribute, EGLint *value)
{
INIT_EXPORT();
if (!export_initialized)
EGLSurface
coregl_api_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativeWindowType win, const EGLint *attrib_list)
+ EGLNativeWindowType win, const EGLint *attrib_list)
{
INIT_EXPORT();
if (!export_initialized)
EGLSurface
coregl_api_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
- const EGLint *attrib_list)
+ const EGLint *attrib_list)
{
INIT_EXPORT();
if (!export_initialized)
EGLSurface
coregl_api_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativePixmapType pixmap, const EGLint *attrib_list)
+ EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
- EGLint attribute, EGLint value)
+ EGLint attribute, EGLint value)
{
INIT_EXPORT();
if (!export_initialized)
EGLContext
coregl_api_eglCreateContext(EGLDisplay dpy, EGLConfig config,
- EGLContext share_context, const EGLint *attrib_list)
+ EGLContext share_context, const EGLint *attrib_list)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
- EGLContext ctx)
+ EGLContext ctx)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
INIT_EXPORT();
if (!export_initialized)
EGLBoolean
coregl_api_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
- EGLNativePixmapType target)
+ EGLNativePixmapType target)
{
INIT_EXPORT();
if (!export_initialized)
}
void
-coregl_api_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+coregl_api_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
ovr_glFrustumf(left, right, bottom, top, zNear, zFar);
}
}
void
-coregl_api_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+coregl_api_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r,
+ GLfloat q)
{
ovr_glMultiTexCoord4f(target, s, t, r, q);
}
}
void
-coregl_api_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+coregl_api_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
ovr_glOrthof(left, right, bottom, top, zNear, zFar);
}
}
void
-coregl_api_glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
+coregl_api_glClearColorx(GLclampx red, GLclampx green, GLclampx blue,
+ GLclampx alpha)
{
ovr_glClearColorx(red, green, blue, alpha);
}
}
void
-coregl_api_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+coregl_api_glColorPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
ovr_glColorPointer(size, type, stride, pointer);
}
}
void
-coregl_api_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+coregl_api_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
ovr_glFrustumx(left, right, bottom, top, zNear, zFar);
}
}
void
-coregl_api_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+coregl_api_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r,
+ GLfixed q)
{
ovr_glMultiTexCoord4x(target, s, t, r, q);
}
}
void
-coregl_api_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+coregl_api_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
ovr_glOrthox(left, right, bottom, top, zNear, zFar);
}
}
void
-coregl_api_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+coregl_api_glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
ovr_glTexCoordPointer(size, type, stride, pointer);
}
}
void
-coregl_api_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+coregl_api_glVertexPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
ovr_glVertexPointer(size, type, stride, pointer);
}
/* Khronos GLES 1.1 CTS requires glPointSizePointerOES as shared library symbol.*/
void
-coregl_api_glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer)
+coregl_api_glPointSizePointerOES(GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
ovr_glPointSizePointerOES(type, stride, pointer);
}
void
coregl_api_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
ovr_glBlendColor(red, green, blue, alpha);
}
void
coregl_api_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
- GLenum dstAlpha)
+ GLenum dstAlpha)
{
ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void
coregl_api_glBufferData(GLenum target, GLsizeiptr size, const void *data,
- GLenum usage)
+ GLenum usage)
{
ovr_glBufferData(target, size, data, usage);
}
void
coregl_api_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
- const void *data)
+ const void *data)
{
ovr_glBufferSubData(target, offset, size, data);
}
void
coregl_api_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
ovr_glClearColor(red, green, blue, alpha);
}
void
coregl_api_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
- GLboolean alpha)
+ GLboolean alpha)
{
ovr_glColorMask(red, green, blue, alpha);
}
void
coregl_api_glCompressedTexImage2D(GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLint border,
- GLsizei imageSize, const void *data)
+ GLenum internalformat, GLsizei width, GLsizei height, GLint border,
+ GLsizei imageSize, const void *data)
{
ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border,
- imageSize, data);
+ imageSize, data);
}
void
coregl_api_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
- const void *data)
+ GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
+ const void *data)
{
ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
- format, imageSize, data);
+ format, imageSize, data);
}
void
coregl_api_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
- GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+ GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height,
- border);
+ border);
}
void
coregl_api_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void
coregl_api_glDrawElements(GLenum mode, GLsizei count, GLenum type,
- const void *indices)
+ const void *indices)
{
ovr_glDrawElements(mode, count, type, indices);
}
void
coregl_api_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
- renderbuffer);
+ renderbuffer);
}
void
coregl_api_glFramebufferTexture2D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void
coregl_api_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
}
void
coregl_api_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
}
void
coregl_api_glGetAttachedShaders(GLuint program, GLsizei maxcount,
- GLsizei *count, GLuint *shaders)
+ GLsizei *count, GLuint *shaders)
{
ovr_glGetAttachedShaders(program, maxcount, count, shaders);
}
void
coregl_api_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
}
void
coregl_api_glGetRenderbufferParameteriv(GLenum target, GLenum pname,
- GLint *params)
+ GLint *params)
{
ovr_glGetRenderbufferParameteriv(target, pname, params);
}
void
coregl_api_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
}
void
coregl_api_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
- GLint *range, GLint *precision)
+ GLint *range, GLint *precision)
{
ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
void
coregl_api_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *source)
+ char *source)
{
ovr_glGetShaderSource(shader, bufsize, length, source);
}
void
coregl_api_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
- GLenum format, GLenum type, void *pixels)
+ GLenum format, GLenum type, void *pixels)
{
ovr_glReadPixels(x, y, width, height, format, type, pixels);
}
void
coregl_api_glRenderbufferStorage(GLenum target, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
ovr_glRenderbufferStorage(target, internalformat, width, height);
}
void
coregl_api_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
- const void *binary, GLsizei length)
+ const void *binary, GLsizei length)
{
ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
}
void
coregl_api_glShaderSource(GLuint shader, GLsizei count, const char **string,
- const GLint *length)
+ const GLint *length)
{
ovr_glShaderSource(shader, count, string, length);
}
void
coregl_api_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
- GLuint mask)
+ GLuint mask)
{
ovr_glStencilFuncSeparate(face, func, ref, mask);
}
void
coregl_api_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
- GLenum zpass)
+ GLenum zpass)
{
ovr_glStencilOpSeparate(face, fail, zfail, zpass);
}
void
coregl_api_glTexImage2D(GLenum target, GLint level, GLint internalformat,
- GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
- const void *pixels)
+ GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
+ const void *pixels)
{
ovr_glTexImage2D(target, level, internalformat, width, height, border, format,
- type, pixels);
+ type, pixels);
}
void
void
coregl_api_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
- const void *pixels)
+ GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
+ const void *pixels)
{
ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
- type, pixels);
+ type, pixels);
}
void
void
coregl_api_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
+ GLfloat w)
{
ovr_glUniform4f(location, x, y, z, w);
}
void
coregl_api_glUniformMatrix2fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix2fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix3fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix3fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix4fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix4fv(location, count, transpose, value);
}
void
coregl_api_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
+ GLfloat w)
{
ovr_glVertexAttrib4f(index, x, y, z, w);
}
void
coregl_api_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
- GLboolean normalized, GLsizei stride, const void *pointer)
+ GLboolean normalized, GLsizei stride, const void *pointer)
{
ovr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}
void
coregl_api_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
- GLsizei count, GLenum type, const GLvoid *indices)
+ GLsizei count, GLenum type, const GLvoid *indices)
{
ovr_glDrawRangeElements(mode, start, end, count, type, indices);
}
void
coregl_api_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat,
- GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
- GLenum type, const GLvoid *pixels)
+ GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
+ GLenum type, const GLvoid *pixels)
{
ovr_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border,
- format, type, pixels);
+ format, type, pixels);
}
void
coregl_api_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLenum type, const GLvoid *pixels)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLenum type, const GLvoid *pixels)
{
ovr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
- depth, format, type, pixels);
+ depth, format, type, pixels);
}
void
coregl_api_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
- height);
+ height);
}
void
coregl_api_glCompressedTexImage3D(GLenum target, GLint level,
- GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLsizei imageSize, const GLvoid *data)
+ GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLsizei imageSize, const GLvoid *data)
{
ovr_glCompressedTexImage3D(target, level, GLinternalformat, width, height,
- depth, border, imageSize, data);
+ depth, border, imageSize, data);
}
void
coregl_api_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLsizei imageSize, const GLvoid *data)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLsizei imageSize, const GLvoid *data)
{
ovr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
- height, depth, format, imageSize, data);
+ height, depth, format, imageSize, data);
}
void
void
coregl_api_glUniformMatrix2x3fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix2x3fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix3x2fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix3x2fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix2x4fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix2x4fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix4x2fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix4x2fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix3x4fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix3x4fv(location, count, transpose, value);
}
void
coregl_api_glUniformMatrix4x3fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glUniformMatrix4x3fv(location, count, transpose, value);
}
void
coregl_api_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
- GLenum filter)
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
+ GLenum filter)
{
ovr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
- mask, filter);
+ mask, filter);
}
void
GLenum internalformat, GLsizei width, GLsizei height)
{
ovr_glRenderbufferStorageMultisample(target, samples, internalformat, width,
- height);
+ height);
}
void
coregl_api_glFramebufferTextureLayer(GLenum target, GLenum attachment,
- GLuint texture, GLint level, GLint layer)
+ GLuint texture, GLint level, GLint layer)
{
ovr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
GLvoid *
coregl_api_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
- GLbitfield access)
+ GLbitfield access)
{
return ovr_glMapBufferRange(target, offset, length, access);
}
void
coregl_api_glFlushMappedBufferRange(GLenum target, GLintptr offset,
- GLsizeiptr length)
+ GLsizeiptr length)
{
ovr_glFlushMappedBufferRange(target, offset, length);
}
void
coregl_api_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
- GLintptr offset, GLsizeiptr size)
+ GLintptr offset, GLsizeiptr size)
{
ovr_glBindBufferRange(target, index, buffer, offset, size);
}
void
coregl_api_glTransformFeedbackVaryings(GLuint program, GLsizei count,
- const GLchar *const *varyings, GLenum bufferMode)
+ const GLchar *const *varyings, GLenum bufferMode)
{
ovr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}
GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
ovr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type,
- name);
+ name);
}
void
coregl_api_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
- GLsizei stride, const GLvoid *pointer)
+ GLsizei stride, const GLvoid *pointer)
{
ovr_glVertexAttribIPointer(index, size, type, stride, pointer);
}
void
coregl_api_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
- GLuint w)
+ GLuint w)
{
ovr_glVertexAttribI4ui(index, x, y, z, w);
}
void
coregl_api_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2,
- GLuint v3)
+ GLuint v3)
{
ovr_glUniform4ui(location, v0, v1, v2, v3);
}
void
coregl_api_glClearBufferuiv(GLenum buffer, GLint drawbuffer,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glClearBufferuiv(buffer, drawbuffer, value);
}
void
coregl_api_glClearBufferfv(GLenum buffer, GLint drawbuffer,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glClearBufferfv(buffer, drawbuffer, value);
}
void
coregl_api_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
- GLint stencil)
+ GLint stencil)
{
ovr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void
coregl_api_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget,
- GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+ GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
ovr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
void
coregl_api_glGetUniformIndices(GLuint program, GLsizei uniformCount,
- const GLchar *const *uniformNames, GLuint *uniformIndices)
+ const GLchar *const *uniformNames, GLuint *uniformIndices)
{
ovr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}
void
coregl_api_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
- const GLuint *uniformIndices, GLenum pname, GLint *params)
+ const GLuint *uniformIndices, GLenum pname, GLint *params)
{
ovr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}
GLuint
coregl_api_glGetUniformBlockIndex(GLuint program,
- const GLchar *uniformBlockName)
+ const GLchar *uniformBlockName)
{
return ovr_glGetUniformBlockIndex(program, uniformBlockName);
}
void
coregl_api_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
ovr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}
void
coregl_api_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
- GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+ GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
{
ovr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
- uniformBlockName);
+ uniformBlockName);
}
void
coregl_api_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
- GLuint uniformBlockBinding)
+ GLuint uniformBlockBinding)
{
ovr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void
coregl_api_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
- GLsizei instanceCount)
+ GLsizei instanceCount)
{
ovr_glDrawArraysInstanced(mode, first, count, instanceCount);
}
void
coregl_api_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
- const GLvoid *indices, GLsizei instanceCount)
+ const GLvoid *indices, GLsizei instanceCount)
{
ovr_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
}
void
coregl_api_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize,
- GLsizei *length, GLint *values)
+ GLsizei *length, GLint *values)
{
ovr_glGetSynciv(sync, pname, bufSize, length, values);
}
void
coregl_api_glGetBufferParameteri64v(GLenum target, GLenum pname,
- GLint64 *params)
+ GLint64 *params)
{
ovr_glGetBufferParameteri64v(target, pname, params);
}
void
coregl_api_glSamplerParameteriv(GLuint sampler, GLenum pname,
- const GLint *param)
+ const GLint *param)
{
ovr_glSamplerParameteriv(sampler, pname, param);
}
void
coregl_api_glSamplerParameterfv(GLuint sampler, GLenum pname,
- const GLfloat *param)
+ const GLfloat *param)
{
ovr_glSamplerParameterfv(sampler, pname, param);
}
void
coregl_api_glGetSamplerParameterfv(GLuint sampler, GLenum pname,
- GLfloat *params)
+ GLfloat *params)
{
ovr_glGetSamplerParameterfv(sampler, pname, params);
}
void
coregl_api_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
- GLenum *binaryFormat, GLvoid *binary)
+ GLenum *binaryFormat, GLvoid *binary)
{
ovr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
}
void
coregl_api_glProgramBinary(GLuint program, GLenum binaryFormat,
- const GLvoid *binary, GLsizei length)
+ const GLvoid *binary, GLsizei length)
{
ovr_glProgramBinary(program, binaryFormat, binary, length);
}
void
coregl_api_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments)
+ const GLenum *attachments)
{
ovr_glInvalidateFramebuffer(target, numAttachments, attachments);
}
void
coregl_api_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
+ const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
- height);
+ height);
}
void
coregl_api_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
ovr_glTexStorage2D(target, levels, internalformat, width, height);
}
void
coregl_api_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height, GLsizei depth)
+ GLsizei width, GLsizei height, GLsizei depth)
{
ovr_glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void
coregl_api_glGetInternalformativ(GLenum target, GLenum internalformat,
- GLenum pname, GLsizei bufSize, GLint *params)
+ GLenum pname, GLsizei bufSize, GLint *params)
{
ovr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
}
/* GLES3.1 API */
GLuint
coregl_api_glCreateShaderProgramv(GLenum type, GLsizei count,
- const GLchar *const *strings)
+ const GLchar *const *strings)
{
return ovr_glCreateShaderProgramv(type, count, strings);
}
void
coregl_api_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
- GLsizei *length, GLchar *infoLog)
+ GLsizei *length, GLchar *infoLog)
{
ovr_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}
void
coregl_api_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
- GLuint num_groups_z)
+ GLuint num_groups_z)
{
ovr_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void
coregl_api_glDrawElementsIndirect(GLenum mode, GLenum type,
- GLvoid const *indirect)
+ GLvoid const *indirect)
{
ovr_glDrawElementsIndirect(mode, type, indirect);
}
void
coregl_api_glGetFramebufferParameteriv( GLenum target, GLenum pname,
- GLint *params)
+ GLint *params)
{
ovr_glGetFramebufferParameteriv(target, pname, params);
}
void
coregl_api_glGetProgramInterfaceiv(GLuint program, GLenum programInterface,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
ovr_glGetProgramInterfaceiv(program, programInterface, pname, params);
}
GLuint
coregl_api_glGetProgramResourceIndex( GLuint program, GLenum programInterface,
- const char *name)
+ const char *name)
{
return ovr_glGetProgramResourceIndex(program, programInterface, name);
}
void
coregl_api_glGetProgramResourceName(GLuint program, GLenum programInterface,
- GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
+ GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
{
ovr_glGetProgramResourceName(program, programInterface, index, bufSize, length,
- name);
+ name);
}
void
coregl_api_glGetProgramResourceiv( GLuint program, GLenum programInterface,
- GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
- GLsizei *length, GLint *params)
+ GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
+ GLsizei *length, GLint *params)
{
ovr_glGetProgramResourceiv(program, programInterface, index, propCount,
- props, bufSize, length, params);
+ props, bufSize, length, params);
}
GLint
coregl_api_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
- GLchar const *name)
+ GLchar const *name)
{
return ovr_glGetProgramResourceLocation(program, programInterface, name);
}
void
coregl_api_glUseProgramStages(GLuint pipeline, GLbitfield stages,
- GLuint program)
+ GLuint program)
{
ovr_glUseProgramStages(pipeline, stages, program);
}
void
coregl_api_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform1iv(program, location, count, value);
}
void
coregl_api_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform2iv(program, location, count, value);
}
void
coregl_api_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform3iv(program, location, count, value);
}
void
coregl_api_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform4iv(program, location, count, value);
}
void
coregl_api_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform1fv(program, location, count, value);
}
void
coregl_api_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform2fv(program, location, count, value);
}
void
coregl_api_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform3fv(program, location, count, value);
}
void
coregl_api_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform4fv(program, location, count, value);
}
void
coregl_api_glProgramUniformMatrix2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
- GLint z)
+ GLint z)
{
ovr_glProgramUniform3i(program, location, x, y, z);
}
void
coregl_api_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
- GLint z, GLint w)
+ GLint z, GLint w)
{
ovr_glProgramUniform4i(program, location, x, y, z, w);
}
void
coregl_api_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
- GLfloat y)
+ GLfloat y)
{
ovr_glProgramUniform2f(program, location, x, y);
}
void
coregl_api_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z)
+ GLfloat y, GLfloat z)
{
ovr_glProgramUniform3f(program, location, x, y, z);
}
void
coregl_api_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z, GLfloat w)
+ GLfloat y, GLfloat z, GLfloat w)
{
ovr_glProgramUniform4f(program, location, x, y, z, w);
}
void
coregl_api_glProgramUniform2ui(GLuint program, GLint location, GLuint x,
- GLuint y)
+ GLuint y)
{
ovr_glProgramUniform2ui(program, location, x, y);
}
void
coregl_api_glProgramUniform3ui(GLuint program, GLint location, GLuint x,
- GLuint y, GLuint z)
+ GLuint y, GLuint z)
{
ovr_glProgramUniform3ui(program, location, x, y, z);
}
void
coregl_api_glProgramUniform4ui(GLuint program, GLint location, GLuint x,
- GLuint y, GLuint z, GLuint w)
+ GLuint y, GLuint z, GLuint w)
{
ovr_glProgramUniform4ui(program, location, x, y, z, w);
}
void
coregl_api_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform1uiv(program, location, count, value);
}
void
coregl_api_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform2uiv(program, location, count, value);
}
void
coregl_api_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform3uiv(program, location, count, value);
}
void
coregl_api_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform4uiv(program, location, count, value);
}
void
coregl_api_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}
void
coregl_api_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}
void
coregl_api_glBindImageTexture (GLuint unit, GLuint texture, GLint level,
- GLboolean layered, GLint layer, GLenum access, GLenum format)
+ GLboolean layered, GLint layer, GLenum access, GLenum format)
{
ovr_glBindImageTexture (unit, texture, level, layered, layer, access, format);
}
void
coregl_api_glTexStorage2DMultisample (GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height,
- GLboolean fixedsamplelocations)
+ GLenum internalformat, GLsizei width, GLsizei height,
+ GLboolean fixedsamplelocations)
{
ovr_glTexStorage2DMultisample (target, samples, internalformat, width, height,
- fixedsamplelocations);
+ fixedsamplelocations);
}
void
void
coregl_api_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
- GLint *params)
+ GLint *params)
{
ovr_glGetTexLevelParameteriv (target, level, pname, params);
}
void
coregl_api_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
- GLfloat *params)
+ GLfloat *params)
{
ovr_glGetTexLevelParameterfv (target, level, pname, params);
}
void
coregl_api_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
- GLintptr offset, GLsizei stride)
+ GLintptr offset, GLsizei stride)
{
ovr_glBindVertexBuffer (bindingindex, buffer, offset, stride);
}
void
coregl_api_glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type,
- GLboolean normalized, GLuint relativeoffset)
+ GLboolean normalized, GLuint relativeoffset)
{
ovr_glVertexAttribFormat (attribindex, size, type, normalized, relativeoffset);
}
void
coregl_api_glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type,
- GLuint relativeoffset)
+ GLuint relativeoffset)
{
ovr_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
}
}
void
-coregl_api_glCopyImageSubData (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)
+coregl_api_glCopyImageSubData (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)
{
- ovr_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel,
-dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+ ovr_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
+ dstTarget, dstLevel,
+ dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void
-coregl_api_glDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count,
-const GLuint *ids, GLboolean enabled)
+coregl_api_glDebugMessageControl (GLenum source, GLenum type, GLenum severity,
+ GLsizei count,
+ const GLuint *ids, GLboolean enabled)
{
ovr_glDebugMessageControl (source, type, severity, count, ids, enabled);
}
void
-coregl_api_glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
-const GLchar *buf)
+coregl_api_glDebugMessageInsert(GLenum source, GLenum type, GLuint id,
+ GLenum severity, GLsizei length,
+ const GLchar *buf)
{
ovr_glDebugMessageInsert(source, type, id, severity, length, buf);
}
}
GLuint
-coregl_api_glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types,
-GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
+coregl_api_glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources,
+ GLenum *types,
+ GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
{
- return ovr_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+ return ovr_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities,
+ lengths, messageLog);
}
void
-coregl_api_glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
+coregl_api_glPushDebugGroup(GLenum source, GLuint id, GLsizei length,
+ const GLchar *message)
{
ovr_glPushDebugGroup(source, id, length, message);
}
}
void
-coregl_api_glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
+coregl_api_glObjectLabel(GLenum identifier, GLuint name, GLsizei length,
+ const GLchar *label)
{
ovr_glObjectLabel(identifier, name, length, label);
}
void
-coregl_api_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
+coregl_api_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
+ GLsizei *length, GLchar *label)
{
ovr_glGetObjectLabel(identifier, name, bufSize, length, label);
}
void
-coregl_api_glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
+coregl_api_glObjectPtrLabel(const void *ptr, GLsizei length,
+ const GLchar *label)
{
ovr_glObjectPtrLabel(ptr, length, label);
}
void
-coregl_api_glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
+coregl_api_glGetObjectPtrLabel(const void *ptr, GLsizei bufSize,
+ GLsizei *length, GLchar *label)
{
ovr_glGetObjectPtrLabel(ptr, bufSize, length, label);
}
}
void
-coregl_api_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
+coregl_api_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB,
+ GLenum modeAlpha)
{
ovr_glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
}
void
-coregl_api_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+coregl_api_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB,
+ GLenum srcAlpha, GLenum dstAlpha)
{
ovr_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void
-coregl_api_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+coregl_api_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b,
+ GLboolean a)
{
ovr_glColorMaski(index, r, g, b, a);
}
}
void
-coregl_api_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices,
-GLint basevertex)
+coregl_api_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const void *indices,
+ GLint basevertex)
{
ovr_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
}
void
-coregl_api_glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count,
-GLenum type, const void *indices, GLint basevertex)
+coregl_api_glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+ GLsizei count,
+ GLenum type, const void *indices, GLint basevertex)
{
- ovr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+ ovr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices,
+ basevertex);
}
void
-coregl_api_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type,
-const void *indices, GLsizei instancecount, GLint basevertex)
+coregl_api_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count,
+ GLenum type,
+ const void *indices, GLsizei instancecount, GLint basevertex)
{
- ovr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+ ovr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
+ basevertex);
}
void
-coregl_api_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+coregl_api_glFramebufferTexture(GLenum target, GLenum attachment,
+ GLuint texture, GLint level)
{
ovr_glFramebufferTexture(target, attachment, texture, level);
}
void
-coregl_api_glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW,
-GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
+coregl_api_glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ,
+ GLfloat minW,
+ GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
{
ovr_glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}
}
void
-coregl_api_glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
-GLsizei bufSize, void *data)
+coregl_api_glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ GLsizei bufSize, void *data)
{
ovr_glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
void
-coregl_api_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
+coregl_api_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize,
+ GLfloat *params)
{
ovr_glGetnUniformfv(program, location, bufSize, params);
}
void
-coregl_api_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
+coregl_api_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize,
+ GLint *params)
{
ovr_glGetnUniformiv(program, location, bufSize, params);
}
void
-coregl_api_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
+coregl_api_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize,
+ GLuint *params)
{
ovr_glGetnUniformuiv(program, location, bufSize, params);
}
}
void
-coregl_api_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
+coregl_api_glSamplerParameterIiv(GLuint sampler, GLenum pname,
+ const GLint *param)
{
ovr_glSamplerParameterIiv(sampler, pname, param);
}
void
-coregl_api_glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
+coregl_api_glSamplerParameterIuiv(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
ovr_glSamplerParameterIuiv(sampler, pname, param);
}
}
void
-coregl_api_glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
+coregl_api_glGetSamplerParameterIuiv(GLuint sampler, GLenum pname,
+ GLuint *params)
{
ovr_glGetSamplerParameterIuiv(sampler, pname, params);
}
}
void
-coregl_api_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset,
-GLsizeiptr size)
+coregl_api_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer,
+ GLintptr offset,
+ GLsizeiptr size)
{
ovr_glTexBufferRange(target, internalformat, buffer, offset, size);
}
void
-coregl_api_glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat,
-GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
+coregl_api_glTexStorage3DMultisample(GLenum target, GLsizei samples,
+ GLenum internalformat,
+ GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
- ovr_glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+ ovr_glTexStorage3DMultisample(target, samples, internalformat, width, height,
+ depth, fixedsamplelocations);
}
#define GL_MAX_COMPUTE_WORK_GROUP_COUNT 0x91BE
/* GLES 3.2 */
-typedef void (GL_APIENTRY *GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity,
-GLsizei length, const GLchar *message, const void *userParam);
+typedef void (GL_APIENTRY *GLDEBUGPROC)(GLenum source, GLenum type, GLuint id,
+ GLenum severity,
+ GLsizei length, const GLchar *message, const void *userParam);
//---------------------------//
// GLES extension defines
_COREGL_SYMBOL(EGLint, eglGetError, (void))
_COREGL_SYMBOL(EGLDisplay, eglGetDisplay, (EGLNativeDisplayType display_id))
_COREGL_SYMBOL(EGLBoolean, eglInitialize, (EGLDisplay dpy, EGLint *major,
- EGLint *minor))
+ EGLint *minor))
_COREGL_SYMBOL(EGLBoolean, eglTerminate, (EGLDisplay dpy))
_COREGL_SYMBOL(const char *, eglQueryString, (EGLDisplay dpy, EGLint name))
_COREGL_SYMBOL(EGLBoolean, eglGetConfigs, (EGLDisplay dpy, EGLConfig *configs,
- EGLint config_size, EGLint *num_config))
+ EGLint config_size, EGLint *num_config))
_COREGL_SYMBOL(EGLBoolean, eglChooseConfig, (EGLDisplay dpy,
- const EGLint *attrib_list, EGLConfig *configs, EGLint config_size,
- EGLint *num_config))
+ const EGLint *attrib_list, EGLConfig *configs, EGLint config_size,
+ EGLint *num_config))
_COREGL_SYMBOL(EGLBoolean, eglGetConfigAttrib, (EGLDisplay dpy,
- EGLConfig config, EGLint attribute, EGLint *value))
+ EGLConfig config, EGLint attribute, EGLint *value))
_COREGL_SYMBOL(EGLSurface, eglCreateWindowSurface, (EGLDisplay dpy,
- EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list))
+ EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list))
_COREGL_SYMBOL(EGLSurface, eglCreatePbufferSurface, (EGLDisplay dpy,
- EGLConfig config, const EGLint *attrib_list))
+ EGLConfig config, const EGLint *attrib_list))
_COREGL_SYMBOL(EGLSurface, eglCreatePixmapSurface, (EGLDisplay dpy,
- EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list))
+ EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list))
_COREGL_SYMBOL(EGLBoolean, eglDestroySurface, (EGLDisplay dpy,
- EGLSurface surface))
+ EGLSurface surface))
_COREGL_SYMBOL(EGLBoolean, eglQuerySurface, (EGLDisplay dpy, EGLSurface surface,
- EGLint attribute, EGLint *value))
+ EGLint attribute, EGLint *value))
_COREGL_SYMBOL(EGLBoolean, eglBindAPI, (EGLenum api))
_COREGL_SYMBOL(EGLenum, eglQueryAPI, (void))
_COREGL_SYMBOL(EGLBoolean, eglWaitClient, (void))
_COREGL_SYMBOL(EGLBoolean, eglReleaseThread, (void))
_COREGL_SYMBOL(EGLSurface, eglCreatePbufferFromClientBuffer, (EGLDisplay dpy,
- EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
- const EGLint *attrib_list))
+ EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
+ const EGLint *attrib_list))
_COREGL_SYMBOL(EGLBoolean, eglSurfaceAttrib, (EGLDisplay dpy,
- EGLSurface surface, EGLint attribute, EGLint value))
+ EGLSurface surface, EGLint attribute, EGLint value))
_COREGL_SYMBOL(EGLBoolean, eglBindTexImage, (EGLDisplay dpy, EGLSurface surface,
- EGLint buffer))
+ EGLint buffer))
_COREGL_SYMBOL(EGLBoolean, eglReleaseTexImage, (EGLDisplay dpy,
- EGLSurface surface, EGLint buffer))
+ EGLSurface surface, EGLint buffer))
_COREGL_SYMBOL(EGLBoolean, eglSwapInterval, (EGLDisplay dpy, EGLint interval))
_COREGL_SYMBOL(EGLContext, eglCreateContext, (EGLDisplay dpy, EGLConfig config,
- EGLContext share_context, const EGLint *attrib_list))
+ EGLContext share_context, const EGLint *attrib_list))
_COREGL_SYMBOL(EGLBoolean, eglDestroyContext, (EGLDisplay dpy, EGLContext ctx))
_COREGL_SYMBOL(EGLBoolean, eglMakeCurrent, (EGLDisplay dpy, EGLSurface draw,
- EGLSurface read, EGLContext ctx))
+ EGLSurface read, EGLContext ctx))
_COREGL_SYMBOL(EGLContext, eglGetCurrentContext, (void))
_COREGL_SYMBOL(EGLSurface, eglGetCurrentSurface, (EGLint readdraw))
_COREGL_SYMBOL(EGLDisplay, eglGetCurrentDisplay, (void))
_COREGL_SYMBOL(EGLBoolean, eglQueryContext, (EGLDisplay dpy, EGLContext ctx,
- EGLint attribute, EGLint *value))
+ EGLint attribute, EGLint *value))
_COREGL_SYMBOL(EGLBoolean, eglWaitGL, (void))
_COREGL_SYMBOL(EGLBoolean, eglWaitNative, (EGLint engine))
_COREGL_SYMBOL(EGLBoolean, eglSwapBuffers, (EGLDisplay dpy, EGLSurface surface))
_COREGL_SYMBOL(EGLBoolean, eglCopyBuffers, (EGLDisplay dpy, EGLSurface surface,
- EGLNativePixmapType target))
+ EGLNativePixmapType target))
_COREGL_SYMBOL(_eng_fn, eglGetProcAddress, (const char *procname))
// Extensions
_COREGL_EXT_SYMBOL(EGLImageKHR, eglCreateImageKHR, (EGLDisplay dpy,
- EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
- const EGLint *attrib_list))
+ EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
+ const EGLint *attrib_list))
_COREGL_EXT_SYMBOL(EGLBoolean, eglDestroyImageKHR, (EGLDisplay dpy,
- EGLImageKHR image))
+ EGLImageKHR image))
_COREGL_EXT_SYMBOL(void *, eglMapImageSEC, (EGLDisplay dpy, EGLImageKHR image,
- EGLint device_type, EGLint access_option))
+ EGLint device_type, EGLint access_option))
_COREGL_EXT_SYMBOL(EGLBoolean, eglUnmapImageSEC, (EGLDisplay dpy,
- EGLImageKHR image, EGLint device_type))
+ EGLImageKHR image, EGLint device_type))
_COREGL_EXT_SYMBOL(EGLBoolean, eglGetImageAttribSEC, (EGLDisplay dpy,
- EGLImageKHR image, EGLint attribute, EGLint *value))
+ EGLImageKHR image, EGLint attribute, EGLint *value))
_COREGL_EXT_SYMBOL(EGLBoolean, eglLockSurfaceKHR, (EGLDisplay display,
- EGLSurface surface, const EGLint *attrib_list))
+ EGLSurface surface, const EGLint *attrib_list))
_COREGL_EXT_SYMBOL(EGLBoolean, eglUnlockSurfaceKHR, (EGLDisplay display,
- EGLSurface surface))
+ EGLSurface surface))
_COREGL_EXT_SYMBOL(EGLBoolean, eglSwapBuffersWithDamageEXT, (EGLDisplay dpy,
- EGLSurface surface, EGLint *rects, EGLint n_rects))
+ EGLSurface surface, EGLint *rects, EGLint n_rects))
_COREGL_EXT_SYMBOL(EGLBoolean, eglSwapBuffersRegionEXT, (EGLDisplay dpy,
- EGLSurface surface, EGLint numRects, const EGLint *rects))
+ EGLSurface surface, EGLint numRects, const EGLint *rects))
_COREGL_EXT_SYMBOL(EGLBoolean, eglBindWaylandDisplayWL, (EGLDisplay dpy,
- void *display))
+ void *display))
_COREGL_EXT_SYMBOL(EGLBoolean, eglUnbindWaylandDisplayWL, (EGLDisplay dpy,
- void *display))
+ void *display))
_COREGL_EXT_SYMBOL(EGLBoolean, eglQueryWaylandBufferWL, (EGLDisplay dpy,
- void *buffer, EGLint attribute, EGLint *value))
+ void *buffer, EGLint attribute, EGLint *value))
_COREGL_EXT_SYMBOL(EGLBoolean, eglSetDamageRegionKHR, (EGLDisplay dpy,
- EGLSurface surface, EGLint *rects, EGLint n_rects))
+ EGLSurface surface, EGLint *rects, EGLint n_rects))
_COREGL_EXT_SYMBOL(EGLBoolean, eglSwapBuffersWithDamageKHR, (EGLDisplay dpy,
- EGLSurface surface, EGLint *rects, EGLint n_rects))
+ EGLSurface surface, EGLint *rects, EGLint n_rects))
/* Fastpath Verified extensions */
//_COREGL_EXT_SYMBOL_FASTPATH_PASS(eglSwapBuffersRegionSEC)
_COREGL_START_API(COREGL_GLAPI_1)
_COREGL_SYMBOL(void, glAlphaFunc, (GLenum func, GLclampf ref))
_COREGL_SYMBOL(void, glClipPlanef, (GLenum plane, const GLfloat *equation))
-_COREGL_SYMBOL(void, glColor4f, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha))
+_COREGL_SYMBOL(void, glColor4f, (GLfloat red, GLfloat green, GLfloat blue,
+ GLfloat alpha))
_COREGL_SYMBOL(void, glFogf, (GLenum pname, GLfloat param))
_COREGL_SYMBOL(void, glFogfv, (GLenum pname, const GLfloat *params))
-_COREGL_SYMBOL(void, glFrustumf, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
+_COREGL_SYMBOL(void, glFrustumf, (GLfloat left, GLfloat right, GLfloat bottom,
+ GLfloat top, GLfloat zNear, GLfloat zFar))
_COREGL_SYMBOL(void, glGetClipPlanef, (GLenum pname, GLfloat eqn[4]))
-_COREGL_SYMBOL(void, glGetLightfv, (GLenum light, GLenum pname, GLfloat *params))
-_COREGL_SYMBOL(void, glGetMaterialfv, (GLenum face, GLenum pname, GLfloat *params))
+_COREGL_SYMBOL(void, glGetLightfv, (GLenum light, GLenum pname,
+ GLfloat *params))
+_COREGL_SYMBOL(void, glGetMaterialfv, (GLenum face, GLenum pname,
+ GLfloat *params))
_COREGL_SYMBOL(void, glGetTexEnvfv, (GLenum env, GLenum pname, GLfloat *params))
_COREGL_SYMBOL(void, glLightModelf, (GLenum pname, GLfloat param))
_COREGL_SYMBOL(void, glLightModelfv, (GLenum pname, const GLfloat *params))
_COREGL_SYMBOL(void, glLightf, (GLenum light, GLenum pname, GLfloat param))
-_COREGL_SYMBOL(void, glLightfv, (GLenum light, GLenum pname, const GLfloat *params))
+_COREGL_SYMBOL(void, glLightfv, (GLenum light, GLenum pname,
+ const GLfloat *params))
_COREGL_SYMBOL(void, glLoadMatrixf, (const GLfloat *m))
_COREGL_SYMBOL(void, glMaterialf, (GLenum face, GLenum pname, GLfloat param))
-_COREGL_SYMBOL(void, glMaterialfv, (GLenum face, GLenum pname, const GLfloat *params))
+_COREGL_SYMBOL(void, glMaterialfv, (GLenum face, GLenum pname,
+ const GLfloat *params))
_COREGL_SYMBOL(void, glMultMatrixf, (const GLfloat *m))
-_COREGL_SYMBOL(void, glMultiTexCoord4f, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q))
+_COREGL_SYMBOL(void, glMultiTexCoord4f, (GLenum target, GLfloat s, GLfloat t,
+ GLfloat r, GLfloat q))
_COREGL_SYMBOL(void, glNormal3f, (GLfloat nx, GLfloat ny, GLfloat nz))
-_COREGL_SYMBOL(void, glOrthof, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
+_COREGL_SYMBOL(void, glOrthof, (GLfloat left, GLfloat right, GLfloat bottom,
+ GLfloat top, GLfloat zNear, GLfloat zFar))
_COREGL_SYMBOL(void, glPointParameterf, (GLenum pname, GLfloat param))
_COREGL_SYMBOL(void, glPointParameterfv, (GLenum pname, const GLfloat *params))
_COREGL_SYMBOL(void, glPointSize, (GLfloat size))
-_COREGL_SYMBOL(void, glRotatef, (GLfloat angle, GLfloat x, GLfloat y, GLfloat z))
+_COREGL_SYMBOL(void, glRotatef, (GLfloat angle, GLfloat x, GLfloat y,
+ GLfloat z))
_COREGL_SYMBOL(void, glScalef, (GLfloat x, GLfloat y, GLfloat z))
_COREGL_SYMBOL(void, glTexEnvf, (GLenum target, GLenum pname, GLfloat param))
-_COREGL_SYMBOL(void, glTexEnvfv, (GLenum target, GLenum pname, const GLfloat *params))
+_COREGL_SYMBOL(void, glTexEnvfv, (GLenum target, GLenum pname,
+ const GLfloat *params))
_COREGL_SYMBOL(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z))
_COREGL_SYMBOL(void, glAlphaFuncx, (GLenum func, GLclampx ref))
-_COREGL_SYMBOL(void, glClearColorx, (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha))
+_COREGL_SYMBOL(void, glClearColorx, (GLclampx red, GLclampx green,
+ GLclampx blue, GLclampx alpha))
_COREGL_SYMBOL(void, glClearDepthx, (GLclampx depth))
_COREGL_SYMBOL(void, glClientActiveTexture, (GLenum texture))
_COREGL_SYMBOL(void, glClipPlanex, (GLenum plane, const GLfixed *equation))
-_COREGL_SYMBOL(void, glColor4ub, (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha))
-_COREGL_SYMBOL(void, glColor4x, (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha))
-_COREGL_SYMBOL(void, glColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer))
+_COREGL_SYMBOL(void, glColor4ub, (GLubyte red, GLubyte green, GLubyte blue,
+ GLubyte alpha))
+_COREGL_SYMBOL(void, glColor4x, (GLfixed red, GLfixed green, GLfixed blue,
+ GLfixed alpha))
+_COREGL_SYMBOL(void, glColorPointer, (GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer))
_COREGL_SYMBOL(void, glDepthRangex, (GLclampx zNear, GLclampx zFar))
_COREGL_SYMBOL(void, glDisableClientState, (GLenum array))
_COREGL_SYMBOL(void, glEnableClientState, (GLenum array))
_COREGL_SYMBOL(void, glFogx, (GLenum pname, GLfixed param))
_COREGL_SYMBOL(void, glFogxv, (GLenum pname, const GLfixed *params))
-_COREGL_SYMBOL(void, glFrustumx, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
+_COREGL_SYMBOL(void, glFrustumx, (GLfixed left, GLfixed right, GLfixed bottom,
+ GLfixed top, GLfixed zNear, GLfixed zFar))
_COREGL_SYMBOL(void, glGetClipPlanex, (GLenum pname, GLfixed eqn[4]))
_COREGL_SYMBOL(void, glGetFixedv, (GLenum pname, GLfixed *params))
-_COREGL_SYMBOL(void, glGetLightxv, (GLenum light, GLenum pname, GLfixed *params))
-_COREGL_SYMBOL(void, glGetMaterialxv, (GLenum face, GLenum pname, GLfixed *params))
+_COREGL_SYMBOL(void, glGetLightxv, (GLenum light, GLenum pname,
+ GLfixed *params))
+_COREGL_SYMBOL(void, glGetMaterialxv, (GLenum face, GLenum pname,
+ GLfixed *params))
_COREGL_SYMBOL(void, glGetTexEnviv, (GLenum env, GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetTexEnvxv, (GLenum env, GLenum pname, GLfixed *params))
-_COREGL_SYMBOL(void, glGetTexParameterxv, (GLenum target, GLenum pname, GLfixed *params))
+_COREGL_SYMBOL(void, glGetTexParameterxv, (GLenum target, GLenum pname,
+ GLfixed *params))
_COREGL_SYMBOL(void, glLightModelx, (GLenum pname, GLfixed param))
_COREGL_SYMBOL(void, glLightModelxv, (GLenum pname, const GLfixed *params))
_COREGL_SYMBOL(void, glLightx, (GLenum light, GLenum pname, GLfixed param))
-_COREGL_SYMBOL(void, glLightxv, (GLenum light, GLenum pname, const GLfixed *params))
+_COREGL_SYMBOL(void, glLightxv, (GLenum light, GLenum pname,
+ const GLfixed *params))
_COREGL_SYMBOL(void, glLineWidthx, (GLfixed width))
_COREGL_SYMBOL(void, glLoadIdentity, (void))
_COREGL_SYMBOL(void, glLoadMatrixx, (const GLfixed *m))
_COREGL_SYMBOL(void, glLogicOp, (GLenum opcode))
_COREGL_SYMBOL(void, glMaterialx, (GLenum face, GLenum pname, GLfixed param))
-_COREGL_SYMBOL(void, glMaterialxv, (GLenum face, GLenum pname, const GLfixed *params))
+_COREGL_SYMBOL(void, glMaterialxv, (GLenum face, GLenum pname,
+ const GLfixed *params))
_COREGL_SYMBOL(void, glMatrixMode, (GLenum mode))
_COREGL_SYMBOL(void, glMultMatrixx, (const GLfixed *m))
-_COREGL_SYMBOL(void, glMultiTexCoord4x, (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q))
+_COREGL_SYMBOL(void, glMultiTexCoord4x, (GLenum target, GLfixed s, GLfixed t,
+ GLfixed r, GLfixed q))
_COREGL_SYMBOL(void, glNormal3x, (GLfixed nx, GLfixed ny, GLfixed nz))
-_COREGL_SYMBOL(void, glNormalPointer, (GLenum type, GLsizei stride, const GLvoid *pointer))
-_COREGL_SYMBOL(void, glOrthox, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
+_COREGL_SYMBOL(void, glNormalPointer, (GLenum type, GLsizei stride,
+ const GLvoid *pointer))
+_COREGL_SYMBOL(void, glOrthox, (GLfixed left, GLfixed right, GLfixed bottom,
+ GLfixed top, GLfixed zNear, GLfixed zFar))
_COREGL_SYMBOL(void, glPointParameterx, (GLenum pname, GLfixed param))
_COREGL_SYMBOL(void, glPointParameterxv, (GLenum pname, const GLfixed *params))
_COREGL_SYMBOL(void, glPointSizex, (GLfixed size))
_COREGL_SYMBOL(void, glPolygonOffsetx, (GLfixed factor, GLfixed units))
_COREGL_SYMBOL(void, glPopMatrix, (void))
_COREGL_SYMBOL(void, glPushMatrix, (void))
-_COREGL_SYMBOL(void, glRotatex, (GLfixed angle, GLfixed x, GLfixed y, GLfixed z) )
+_COREGL_SYMBOL(void, glRotatex, (GLfixed angle, GLfixed x, GLfixed y,
+ GLfixed z) )
_COREGL_SYMBOL(void, glSampleCoveragex, (GLclampx value, GLboolean invert))
_COREGL_SYMBOL(void, glScalex, (GLfixed x, GLfixed y, GLfixed z))
_COREGL_SYMBOL(void, glShadeModel, (GLenum mode))
-_COREGL_SYMBOL(void, glTexCoordPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer))
+_COREGL_SYMBOL(void, glTexCoordPointer, (GLint size, GLenum type,
+ GLsizei stride, const GLvoid *pointer))
_COREGL_SYMBOL(void, glTexEnvi, (GLenum target, GLenum pname, GLint param))
_COREGL_SYMBOL(void, glTexEnvx, (GLenum target, GLenum pname, GLfixed param))
-_COREGL_SYMBOL(void, glTexEnviv, (GLenum target, GLenum pname, const GLint *params))
-_COREGL_SYMBOL(void, glTexEnvxv, (GLenum target, GLenum pname, const GLfixed *params))
-_COREGL_SYMBOL(void, glTexParameterx, (GLenum target, GLenum pname, GLfixed param))
-_COREGL_SYMBOL(void, glTexParameterxv, (GLenum target, GLenum pname, const GLfixed *params))
+_COREGL_SYMBOL(void, glTexEnviv, (GLenum target, GLenum pname,
+ const GLint *params))
+_COREGL_SYMBOL(void, glTexEnvxv, (GLenum target, GLenum pname,
+ const GLfixed *params))
+_COREGL_SYMBOL(void, glTexParameterx, (GLenum target, GLenum pname,
+ GLfixed param))
+_COREGL_SYMBOL(void, glTexParameterxv, (GLenum target, GLenum pname,
+ const GLfixed *params))
_COREGL_SYMBOL(void, glTranslatex, (GLfixed x, GLfixed y, GLfixed z))
-_COREGL_SYMBOL(void, glVertexPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer))
+_COREGL_SYMBOL(void, glVertexPointer, (GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer))
/* Khronos GLES 1.1 CTS requires glPointSizePointerOES as shared library symbol.*/
-_COREGL_SYMBOL(void, glPointSizePointerOES, (GLenum type, GLsizei stride, const GLvoid *pointer))
+_COREGL_SYMBOL(void, glPointSizePointerOES, (GLenum type, GLsizei stride,
+ const GLvoid *pointer))
//OpenGL ES 1.1 extensions
-_COREGL_EXT_SYMBOL(void, glDrawTexsOES, (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height))
-_COREGL_EXT_SYMBOL(void, glDrawTexiOES, (GLint x, GLint y, GLint z, GLint width, GLint height))
-_COREGL_EXT_SYMBOL(void, glDrawTexxOES, (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height))
+_COREGL_EXT_SYMBOL(void, glDrawTexsOES, (GLshort x, GLshort y, GLshort z,
+ GLshort width, GLshort height))
+_COREGL_EXT_SYMBOL(void, glDrawTexiOES, (GLint x, GLint y, GLint z, GLint width,
+ GLint height))
+_COREGL_EXT_SYMBOL(void, glDrawTexxOES, (GLfixed x, GLfixed y, GLfixed z,
+ GLfixed width, GLfixed height))
_COREGL_EXT_SYMBOL(void, glDrawTexsvOES, (const GLshort *coords))
_COREGL_EXT_SYMBOL(void, glDrawTexivOES, (const GLint *coords))
_COREGL_EXT_SYMBOL(void, glDrawTexxvOES, (const GLfixed *coords))
-_COREGL_EXT_SYMBOL(void, glDrawTexfOES, (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height))
+_COREGL_EXT_SYMBOL(void, glDrawTexfOES, (GLfloat x, GLfloat y, GLfloat z,
+ GLfloat width, GLfloat height))
_COREGL_EXT_SYMBOL(void, glDrawTexfvOES, (const GLfloat *coords))
_COREGL_EXT_SYMBOL(void, glCurrentPaletteMatrixOES, (GLuint matrixpaletteindex))
_COREGL_EXT_SYMBOL(void, glLoadPaletteFromModelViewMatrixOES, (void))
-_COREGL_EXT_SYMBOL(void, glMatrixIndexPointerOES, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer))
-_COREGL_EXT_SYMBOL(void, glWeightPointerOES, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer))
-_COREGL_EXT_SYMBOL(GLbitfield, glQueryMatrixxOES, (GLfixed mantissa[16], GLint exponent[16]))
-_COREGL_EXT_SYMBOL(void, glTexGenfOES, (GLenum coord, GLenum pname, GLfloat param))
-_COREGL_EXT_SYMBOL(void, glTexGenfvOES, (GLenum coord, GLenum pname, const GLfloat *params))
-_COREGL_EXT_SYMBOL(void, glTexGeniOES, (GLenum coord, GLenum pname, GLint param))
-_COREGL_EXT_SYMBOL(void, glTexGenivOES, (GLenum coord, GLenum pname, const GLint *params))
-_COREGL_EXT_SYMBOL(void, glTexGenxOES, (GLenum coord, GLenum pname, GLfixed param))
-_COREGL_EXT_SYMBOL(void, glTexGenxvOES, (GLenum coord, GLenum pname, const GLfixed *params))
-_COREGL_EXT_SYMBOL(void, glGetTexGenfvOES, (GLenum coord, GLenum pname, GLfloat *params))
-_COREGL_EXT_SYMBOL(void, glGetTexGenivOES, (GLenum coord, GLenum pname, GLint *params))
-_COREGL_EXT_SYMBOL(void, glGetTexGenxvOES, (GLenum coord, GLenum pname, GLfixed *params))
+_COREGL_EXT_SYMBOL(void, glMatrixIndexPointerOES, (GLint size, GLenum type,
+ GLsizei stride, const GLvoid *pointer))
+_COREGL_EXT_SYMBOL(void, glWeightPointerOES, (GLint size, GLenum type,
+ GLsizei stride, const GLvoid *pointer))
+_COREGL_EXT_SYMBOL(GLbitfield, glQueryMatrixxOES, (GLfixed mantissa[16],
+ GLint exponent[16]))
+_COREGL_EXT_SYMBOL(void, glTexGenfOES, (GLenum coord, GLenum pname,
+ GLfloat param))
+_COREGL_EXT_SYMBOL(void, glTexGenfvOES, (GLenum coord, GLenum pname,
+ const GLfloat *params))
+_COREGL_EXT_SYMBOL(void, glTexGeniOES, (GLenum coord, GLenum pname,
+ GLint param))
+_COREGL_EXT_SYMBOL(void, glTexGenivOES, (GLenum coord, GLenum pname,
+ const GLint *params))
+_COREGL_EXT_SYMBOL(void, glTexGenxOES, (GLenum coord, GLenum pname,
+ GLfixed param))
+_COREGL_EXT_SYMBOL(void, glTexGenxvOES, (GLenum coord, GLenum pname,
+ const GLfixed *params))
+_COREGL_EXT_SYMBOL(void, glGetTexGenfvOES, (GLenum coord, GLenum pname,
+ GLfloat *params))
+_COREGL_EXT_SYMBOL(void, glGetTexGenivOES, (GLenum coord, GLenum pname,
+ GLint *params))
+_COREGL_EXT_SYMBOL(void, glGetTexGenxvOES, (GLenum coord, GLenum pname,
+ GLfixed *params))
_COREGL_EXT_SYMBOL(void, glClipPlanefIMG, (GLenum, const GLfloat *))
_COREGL_EXT_SYMBOL(void, glClipPlanexIMG, (GLenum, const GLfixed *))
_COREGL_END_API(COREGL_GLAPI_1)
_COREGL_START_API(COREGL_GLAPI_2)
_COREGL_SYMBOL(void, glAttachShader, (GLuint program, GLuint shader))
_COREGL_SYMBOL(void, glBindAttribLocation, (GLuint program, GLuint index,
- const char *name))
+ const char *name))
_COREGL_SYMBOL(void, glBindFramebuffer, (GLenum target, GLuint framebuffer))
_COREGL_SYMBOL(void, glBindRenderbuffer, (GLenum target, GLuint renderbuffer))
_COREGL_SYMBOL(void, glBlendColor, (GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha))
+ GLclampf alpha))
_COREGL_SYMBOL(void, glBlendEquation, ( GLenum mode ))
_COREGL_SYMBOL(void, glBlendEquationSeparate, (GLenum modeRGB,
- GLenum modeAlpha))
+ GLenum modeAlpha))
_COREGL_SYMBOL(void, glBlendFuncSeparate, (GLenum srcRGB, GLenum dstRGB,
- GLenum srcAlpha, GLenum dstAlpha))
+ GLenum srcAlpha, GLenum dstAlpha))
_COREGL_SYMBOL(GLenum, glCheckFramebufferStatus, (GLenum target))
_COREGL_SYMBOL(void, glCompileShader, (GLuint shader))
_COREGL_SYMBOL(GLuint, glCreateProgram, (void))
_COREGL_SYMBOL(GLuint, glCreateShader, (GLenum type))
_COREGL_SYMBOL(void, glDeleteFramebuffers, (GLsizei n,
- const GLuint *framebuffers))
+ const GLuint *framebuffers))
_COREGL_SYMBOL(void, glDeleteProgram, (GLuint program))
_COREGL_SYMBOL(void, glDeleteRenderbuffers, (GLsizei n,
- const GLuint *renderbuffers))
+ const GLuint *renderbuffers))
_COREGL_SYMBOL(void, glDeleteShader, (GLuint shader))
_COREGL_SYMBOL(void, glDetachShader, (GLuint program, GLuint shader))
_COREGL_SYMBOL(void, glDisableVertexAttribArray, (GLuint index))
_COREGL_SYMBOL(void, glEnableVertexAttribArray, (GLuint index))
_COREGL_SYMBOL(void, glFramebufferRenderbuffer, (GLenum target,
- GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer))
+ GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer))
_COREGL_SYMBOL(void, glFramebufferTexture2D, (GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level))
+ GLenum textarget, GLuint texture, GLint level))
_COREGL_SYMBOL(void, glGenerateMipmap, (GLenum target))
_COREGL_SYMBOL(void, glGenFramebuffers, (GLsizei n, GLuint *framebuffers))
_COREGL_SYMBOL(void, glGenRenderbuffers, (GLsizei n, GLuint *renderbuffers))
_COREGL_SYMBOL(void, glGetActiveAttrib, (GLuint program, GLuint index,
- GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name))
+ GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name))
_COREGL_SYMBOL(void, glGetActiveUniform, (GLuint program, GLuint index,
- GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name))
+ GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name))
_COREGL_SYMBOL(void, glGetAttachedShaders, (GLuint program, GLsizei maxcount,
- GLsizei *count, GLuint *shaders))
+ GLsizei *count, GLuint *shaders))
_COREGL_SYMBOL(int, glGetAttribLocation, (GLuint program, const char *name))
_COREGL_SYMBOL(void, glGetFramebufferAttachmentParameteriv, (GLenum target,
- GLenum attachment, GLenum pname, GLint *params))
+ GLenum attachment, GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetProgramiv, (GLuint program, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetProgramInfoLog, (GLuint program, GLsizei bufsize,
- GLsizei *length, char *infolog))
+ GLsizei *length, char *infolog))
_COREGL_SYMBOL(void, glGetRenderbufferParameteriv, (GLenum target, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetShaderiv, (GLuint shader, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetShaderInfoLog, (GLuint shader, GLsizei bufsize,
- GLsizei *length, char *infolog))
+ GLsizei *length, char *infolog))
_COREGL_SYMBOL(void, glGetShaderPrecisionFormat, (GLenum shadertype,
- GLenum precisiontype, GLint *range, GLint *precision))
+ GLenum precisiontype, GLint *range, GLint *precision))
_COREGL_SYMBOL(void, glGetShaderSource, (GLuint shader, GLsizei bufsize,
- GLsizei *length, char *source))
+ GLsizei *length, char *source))
_COREGL_SYMBOL(void, glGetUniformfv, (GLuint program, GLint location,
- GLfloat *params))
+ GLfloat *params))
_COREGL_SYMBOL(void, glGetUniformiv, (GLuint program, GLint location,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(int, glGetUniformLocation, (GLuint program, const char *name))
_COREGL_SYMBOL(void, glGetVertexAttribfv, (GLuint index, GLenum pname,
- GLfloat *params))
+ GLfloat *params))
_COREGL_SYMBOL(void, glGetVertexAttribiv, (GLuint index, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetVertexAttribPointerv, (GLuint index, GLenum pname,
- void **pointer))
+ void **pointer))
_COREGL_SYMBOL(GLboolean, glIsFramebuffer, (GLuint framebuffer))
_COREGL_SYMBOL(GLboolean, glIsProgram, (GLuint program))
_COREGL_SYMBOL(GLboolean, glIsRenderbuffer, (GLuint renderbuffer))
_COREGL_SYMBOL(void, glLinkProgram, (GLuint program))
_COREGL_SYMBOL(void, glReleaseShaderCompiler, (void))
_COREGL_SYMBOL(void, glRenderbufferStorage, (GLenum target,
- GLenum internalformat, GLsizei width, GLsizei height))
+ GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_SYMBOL(void, glShaderBinary, (GLsizei n, const GLuint *shaders,
- GLenum binaryformat, const void *binary, GLsizei length))
+ GLenum binaryformat, const void *binary, GLsizei length))
_COREGL_SYMBOL(void, glShaderSource, (GLuint shader, GLsizei count,
- const char **string, const GLint *length))
+ const char **string, const GLint *length))
_COREGL_SYMBOL(void, glStencilFuncSeparate, (GLenum face, GLenum func,
- GLint ref, GLuint mask))
+ GLint ref, GLuint mask))
_COREGL_SYMBOL(void, glStencilMaskSeparate, (GLenum face, GLuint mask))
_COREGL_SYMBOL(void, glStencilOpSeparate, (GLenum face, GLenum fail,
- GLenum zfail, GLenum zpass))
+ GLenum zfail, GLenum zpass))
_COREGL_SYMBOL(void, glUniform1f, (GLint location, GLfloat x))
_COREGL_SYMBOL(void, glUniform1fv, (GLint location, GLsizei count,
- const GLfloat *v))
+ const GLfloat *v))
_COREGL_SYMBOL(void, glUniform1i, (GLint location, GLint x))
_COREGL_SYMBOL(void, glUniform1iv, (GLint location, GLsizei count,
- const GLint *v))
+ const GLint *v))
_COREGL_SYMBOL(void, glUniform2f, (GLint location, GLfloat x, GLfloat y))
_COREGL_SYMBOL(void, glUniform2fv, (GLint location, GLsizei count,
- const GLfloat *v))
+ const GLfloat *v))
_COREGL_SYMBOL(void, glUniform2i, (GLint location, GLint x, GLint y))
_COREGL_SYMBOL(void, glUniform2iv, (GLint location, GLsizei count,
- const GLint *v))
+ const GLint *v))
_COREGL_SYMBOL(void, glUniform3f, (GLint location, GLfloat x, GLfloat y,
- GLfloat z))
+ GLfloat z))
_COREGL_SYMBOL(void, glUniform3fv, (GLint location, GLsizei count,
- const GLfloat *v))
+ const GLfloat *v))
_COREGL_SYMBOL(void, glUniform3i, (GLint location, GLint x, GLint y, GLint z))
_COREGL_SYMBOL(void, glUniform3iv, (GLint location, GLsizei count,
- const GLint *v))
+ const GLint *v))
_COREGL_SYMBOL(void, glUniform4f, (GLint location, GLfloat x, GLfloat y,
- GLfloat z, GLfloat w))
+ GLfloat z, GLfloat w))
_COREGL_SYMBOL(void, glUniform4fv, (GLint location, GLsizei count,
- const GLfloat *v))
+ const GLfloat *v))
_COREGL_SYMBOL(void, glUniform4i, (GLint location, GLint x, GLint y, GLint z,
- GLint w))
+ GLint w))
_COREGL_SYMBOL(void, glUniform4iv, (GLint location, GLsizei count,
- const GLint *v))
+ const GLint *v))
_COREGL_SYMBOL(void, glUniformMatrix2fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix3fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix4fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUseProgram, (GLuint program))
_COREGL_SYMBOL(void, glValidateProgram, (GLuint program))
_COREGL_SYMBOL(void, glVertexAttrib1f, (GLuint index, GLfloat x))
_COREGL_SYMBOL(void, glVertexAttrib2f, (GLuint index, GLfloat x, GLfloat y))
_COREGL_SYMBOL(void, glVertexAttrib2fv, (GLuint index, const GLfloat *values))
_COREGL_SYMBOL(void, glVertexAttrib3f, (GLuint index, GLfloat x, GLfloat y,
- GLfloat z))
+ GLfloat z))
_COREGL_SYMBOL(void, glVertexAttrib3fv, (GLuint index, const GLfloat *values))
_COREGL_SYMBOL(void, glVertexAttrib4f, (GLuint index, GLfloat x, GLfloat y,
- GLfloat z, GLfloat w))
+ GLfloat z, GLfloat w))
_COREGL_SYMBOL(void, glVertexAttrib4fv, (GLuint index, const GLfloat *values))
_COREGL_SYMBOL(void, glVertexAttribPointer, (GLuint index, GLint size,
- GLenum type, GLboolean normalized, GLsizei stride, const void *pointer))
+ GLenum type, GLboolean normalized, GLsizei stride, const void *pointer))
_COREGL_EXT_SYMBOL(void, glBindFramebufferOES, (GLenum target,
- GLuint framebuffer))
+ GLuint framebuffer))
_COREGL_EXT_SYMBOL(void, glBindRenderbufferOES, (GLenum target,
- GLuint renderbuffer))
+ GLuint renderbuffer))
_COREGL_EXT_SYMBOL(void, glDeleteFramebuffersOES, (GLsizei n,
- const GLuint *framebuffers))
+ const GLuint *framebuffers))
_COREGL_EXT_SYMBOL(void, glDeleteRenderbuffersOES, (GLsizei n,
- const GLuint *renderbuffers))
+ const GLuint *renderbuffers))
_COREGL_EXT_SYMBOL(void, glDepthRangefOES, (GLclampf zNear, GLclampf zFar))
_COREGL_EXT_SYMBOL(void, glDepthRangexOES, (GLclampx zNear, GLclampx zFar))
_COREGL_EXT_SYMBOL(void, glFramebufferRenderbufferOES, (GLenum target,
- GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer))
+ GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer))
_COREGL_EXT_SYMBOL(void, glFramebufferTexture2DOES, (GLenum target,
- GLenum attachment, GLenum textarget, GLuint texture, GLint level))
-_COREGL_EXT_SYMBOL(void, glFramebufferTextureOES, (GLenum target, GLenum attachment, GLuint texture, GLint level))
-_COREGL_EXT_SYMBOL(void, glTexBufferRangeOES, (GLenum target, GLenum internalformat, GLuint buffer,GLintptr offset, GLsizeiptr size))
-_COREGL_EXT_SYMBOL(void, glSamplerParameterIuivOES, (GLuint sampler, GLenum pname, GLuint const *params))
-_COREGL_EXT_SYMBOL(void, glSamplerParameterIivOES, (GLuint sampler, GLenum pname, GLint const *params))
-_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIuivOES,(GLuint sampler, GLenum pname, GLuint *params))
-_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIivOES,(GLuint sampler, GLenum pname, GLint *params))
-_COREGL_EXT_SYMBOL(void, glGetTexParameterIuivOES,(GLenum target, GLenum pname, GLuint *params))
-_COREGL_EXT_SYMBOL(void, glGetTexParameterIivOES,(GLenum target, GLenum pname, GLint *params))
-_COREGL_EXT_SYMBOL(void, glPatchParameteriOES,(GLenum pname, GLint value))
-_COREGL_EXT_SYMBOL(void, glTexParameterIivOES,(GLenum target, GLenum pname, GLint const *params))
-_COREGL_EXT_SYMBOL(void, glTexParameterIuivOES,(GLenum target, GLenum pname, GLuint const *params))
-_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIivEXT,(GLuint sampler, GLenum pname, GLint *params))
-_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIuivEXT,(GLuint sampler, GLenum pname, GLuint *params))
-_COREGL_EXT_SYMBOL(void, glSamplerParameterIivEXT, (GLuint sampler, GLenum pname, GLint const *params))
-_COREGL_EXT_SYMBOL(void, glFramebufferTextureEXT, (GLenum target, GLenum attachment, GLuint texture, GLint level))
-_COREGL_EXT_SYMBOL(void, glTexBufferRangeEXT, (GLenum target, GLenum internalformat, GLuint buffer,GLintptr offset, GLsizeiptr size))
-_COREGL_EXT_SYMBOL(void, glSamplerParameterIuivEXT, (GLuint sampler, GLenum pname, GLuint const *params))
-_COREGL_EXT_SYMBOL(void, glGetTexParameterIuivEXT,(GLenum target, GLenum pname, GLuint *params))
-_COREGL_EXT_SYMBOL(void, glGetTexParameterIivEXT,(GLenum target, GLenum pname, GLint *params))
-_COREGL_EXT_SYMBOL(void, glPatchParameteriEXT,(GLenum pname, GLint value))
-_COREGL_EXT_SYMBOL(void, glTexParameterIivEXT,(GLenum target, GLenum pname, GLint const *params))
-_COREGL_EXT_SYMBOL(void, glTexParameterIuivEXT,(GLenum target, GLenum pname, GLuint const *params))
+ GLenum attachment, GLenum textarget, GLuint texture, GLint level))
+_COREGL_EXT_SYMBOL(void, glFramebufferTextureOES, (GLenum target,
+ GLenum attachment, GLuint texture, GLint level))
+_COREGL_EXT_SYMBOL(void, glTexBufferRangeOES, (GLenum target,
+ GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size))
+_COREGL_EXT_SYMBOL(void, glSamplerParameterIuivOES, (GLuint sampler,
+ GLenum pname, GLuint const *params))
+_COREGL_EXT_SYMBOL(void, glSamplerParameterIivOES, (GLuint sampler,
+ GLenum pname, GLint const *params))
+_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIuivOES, (GLuint sampler,
+ GLenum pname, GLuint *params))
+_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIivOES, (GLuint sampler,
+ GLenum pname, GLint *params))
+_COREGL_EXT_SYMBOL(void, glGetTexParameterIuivOES, (GLenum target, GLenum pname,
+ GLuint *params))
+_COREGL_EXT_SYMBOL(void, glGetTexParameterIivOES, (GLenum target, GLenum pname,
+ GLint *params))
+_COREGL_EXT_SYMBOL(void, glPatchParameteriOES, (GLenum pname, GLint value))
+_COREGL_EXT_SYMBOL(void, glTexParameterIivOES, (GLenum target, GLenum pname,
+ GLint const *params))
+_COREGL_EXT_SYMBOL(void, glTexParameterIuivOES, (GLenum target, GLenum pname,
+ GLuint const *params))
+_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIivEXT, (GLuint sampler,
+ GLenum pname, GLint *params))
+_COREGL_EXT_SYMBOL(void, glGetSamplerParameterIuivEXT, (GLuint sampler,
+ GLenum pname, GLuint *params))
+_COREGL_EXT_SYMBOL(void, glSamplerParameterIivEXT, (GLuint sampler,
+ GLenum pname, GLint const *params))
+_COREGL_EXT_SYMBOL(void, glFramebufferTextureEXT, (GLenum target,
+ GLenum attachment, GLuint texture, GLint level))
+_COREGL_EXT_SYMBOL(void, glTexBufferRangeEXT, (GLenum target,
+ GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size))
+_COREGL_EXT_SYMBOL(void, glSamplerParameterIuivEXT, (GLuint sampler,
+ GLenum pname, GLuint const *params))
+_COREGL_EXT_SYMBOL(void, glGetTexParameterIuivEXT, (GLenum target, GLenum pname,
+ GLuint *params))
+_COREGL_EXT_SYMBOL(void, glGetTexParameterIivEXT, (GLenum target, GLenum pname,
+ GLint *params))
+_COREGL_EXT_SYMBOL(void, glPatchParameteriEXT, (GLenum pname, GLint value))
+_COREGL_EXT_SYMBOL(void, glTexParameterIivEXT, (GLenum target, GLenum pname,
+ GLint const *params))
+_COREGL_EXT_SYMBOL(void, glTexParameterIuivEXT, (GLenum target, GLenum pname,
+ GLuint const *params))
_COREGL_EXT_SYMBOL(void, glGenFramebuffersOES, (GLsizei n,
- GLuint *framebuffers))
+ GLuint *framebuffers))
_COREGL_EXT_SYMBOL(void, glGenRenderbuffersOES, (GLsizei n,
- GLuint *renderbuffers))
+ GLuint *renderbuffers))
_COREGL_EXT_SYMBOL(void, glGetFramebufferAttachmentParameterivOES,
- (GLenum target, GLenum attachment, GLenum pname, GLint *params))
+ (GLenum target, GLenum attachment, GLenum pname, GLint *params))
_COREGL_EXT_SYMBOL(void, glFramebufferTexture3DOES, (GLenum target,
- GLenum attachment, GLenum textarget, GLuint texture, GLint level,
- GLint zoffset))
+ GLenum attachment, GLenum textarget, GLuint texture, GLint level,
+ GLint zoffset))
_COREGL_EXT_SYMBOL(GLboolean, glIsFramebufferOES, (GLuint framebuffer))
_COREGL_EXT_SYMBOL(GLboolean, glIsRenderbufferOES, (GLuint renderbuffer))
_COREGL_EXT_SYMBOL(void, glAlphaFuncxOES, (GLenum func, GLclampx ref))
_COREGL_EXT_SYMBOL(void, glBlendBarrierKHR, (void))
_COREGL_EXT_SYMBOL(void, glBlendEquationOES, (GLenum mode))
_COREGL_EXT_SYMBOL(void, glBlendEquationSeparateOES, (GLenum modeRGB,
- GLenum modeAlpha))
+ GLenum modeAlpha))
_COREGL_EXT_SYMBOL(void, glBlendFuncSeparateOES, (GLenum srcRGB, GLenum dstRGB,
- GLenum srcAlpha, GLenum dstAlpha))
+ GLenum srcAlpha, GLenum dstAlpha))
_COREGL_EXT_SYMBOL(GLenum, glCheckFramebufferStatusOES, (GLenum target))
_COREGL_EXT_SYMBOL(void, glClearColorxOES, (GLclampx red, GLclampx green,
- GLclampx blue, GLclampx alpha))
+ GLclampx blue, GLclampx alpha))
_COREGL_EXT_SYMBOL(void, glClearDepthfOES, (GLclampf depth))
_COREGL_EXT_SYMBOL(void, glClearDepthxOES, (GLclampx depth))
_COREGL_EXT_SYMBOL(void, glClipPlanefOES, (GLenum plane,
- GLfloat const *equation))
+ GLfloat const *equation))
_COREGL_EXT_SYMBOL(void, glClipPlanexOES, (GLenum plane,
- GLfixed const *equation))
+ GLfixed const *equation))
_COREGL_EXT_SYMBOL(void, glColor4xOES, (GLfixed red, GLfixed green,
- GLfixed blue, GLfixed alpha))
+ GLfixed blue, GLfixed alpha))
_COREGL_EXT_SYMBOL(void, glFogxOES, (GLenum pname, GLfixed param))
_COREGL_EXT_SYMBOL(void, glFogxvOES, (GLenum pname, GLfixed const *params))
_COREGL_EXT_SYMBOL(void, glFrustumxOES, (GLfixed left, GLfixed right,
- GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
+ GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
_COREGL_EXT_SYMBOL(void, glFrustumfOES, (GLfloat left, GLfloat right,
- GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
+ GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
_COREGL_EXT_SYMBOL(void, glGenerateMipmapOES, (GLenum target))
_COREGL_EXT_SYMBOL(void, glGetClipPlanefOES, (GLenum pname, GLfloat eqn[4]))
_COREGL_EXT_SYMBOL(void, glGetClipPlanexOES, (GLenum pname, GLfixed eqn[4]))
_COREGL_EXT_SYMBOL(void, glGetPointervKHR, (GLenum pname, GLvoid **params))
_COREGL_EXT_SYMBOL(void, glDebugMessageCallbackKHR, (GLDEBUGPROCKHR callback,
- void const *userParam))
+ void const *userParam))
_COREGL_EXT_SYMBOL(void, glDebugMessageControlKHR, (GLenum source, GLenum type,
- GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled))
+ GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled))
_COREGL_EXT_SYMBOL(void, glDebugMessageInsertKHR, (GLenum source, GLenum type,
- GLuint id, GLenum severity, GLsizei length, GLchar const *buf))
+ GLuint id, GLenum severity, GLsizei length, GLchar const *buf))
_COREGL_EXT_SYMBOL(GLuint, glGetDebugMessageLogKHR, (GLuint count,
- GLsizei bufsize, GLenum *sources, GLenum *types, GLuint *ids,
- GLenum *severities, GLsizei *lengths, GLchar *messageLog))
+ GLsizei bufsize, GLenum *sources, GLenum *types, GLuint *ids,
+ GLenum *severities, GLsizei *lengths, GLchar *messageLog))
_COREGL_EXT_SYMBOL(void, glGetObjectLabelKHR, (GLenum identifier, GLuint name,
- GLsizei bufSize, GLsizei *length, GLchar *label))
+ GLsizei bufSize, GLsizei *length, GLchar *label))
_COREGL_EXT_SYMBOL(void, glGetObjectPtrLabelKHR, (void const *ptr,
- GLsizei bufSize, GLsizei *length, GLchar *label))
+ GLsizei bufSize, GLsizei *length, GLchar *label))
_COREGL_EXT_SYMBOL(void, glObjectLabelKHR, (GLenum identifier, GLuint name,
- GLsizei length, const GLchar *label))
+ GLsizei length, const GLchar *label))
_COREGL_EXT_SYMBOL(void, glObjectPtrLabelKHR, (const void *ptr, GLsizei length,
- const GLchar *label))
+ const GLchar *label))
_COREGL_EXT_SYMBOL(void, glPopDebugGroupKHR, (void))
_COREGL_EXT_SYMBOL(void, glPushDebugGroupKHR, (GLenum source, GLuint id,
- GLsizei length, const GLchar *message))
+ GLsizei length, const GLchar *message))
_COREGL_EXT_SYMBOL(void, glGetFixedvOES, (GLenum pname, GLfixed *params))
_COREGL_EXT_SYMBOL(void, glGetLightxvOES, (GLenum light, GLenum pname,
- GLfixed *params))
+ GLfixed *params))
_COREGL_EXT_SYMBOL(void, glGetMaterialxvOES, (GLenum face, GLenum pname,
- GLfixed *params))
+ GLfixed *params))
_COREGL_EXT_SYMBOL(void, glGetRenderbufferParameterivOES, (GLenum target,
- GLenum pname, GLint *params))
+ GLenum pname, GLint *params))
_COREGL_EXT_SYMBOL(void, glGetTexEnvxvOES, (GLenum env, GLenum pname,
- GLfixed *params))
+ GLfixed *params))
_COREGL_EXT_SYMBOL(void, glGetTexParameterxvOES, (GLenum target, GLenum pname,
- GLfixed *params))
+ GLfixed *params))
_COREGL_EXT_SYMBOL(void, glLightModelxOES, (GLenum pname, GLfixed param))
_COREGL_EXT_SYMBOL(void, glLightModelxvOES, (GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glLightxOES, (GLenum light, GLenum pname,
- GLfixed param))
+ GLfixed param))
_COREGL_EXT_SYMBOL(void, glLightxvOES, (GLenum light, GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glLineWidthxOES, (GLfixed width))
_COREGL_EXT_SYMBOL(void, glLoadMatrixxOES, (const GLfixed *m))
_COREGL_EXT_SYMBOL(void, glMaterialxOES, (GLenum face, GLenum pname,
- GLfixed param))
+ GLfixed param))
_COREGL_EXT_SYMBOL(void, glMaterialxvOES, (GLenum face, GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glMultMatrixxOES, (const GLfixed *m))
_COREGL_EXT_SYMBOL(void, glMultiTexCoord4bOES, (GLenum target, GLbyte s,
- GLbyte t, GLbyte r, GLbyte q))
+ GLbyte t, GLbyte r, GLbyte q))
_COREGL_EXT_SYMBOL(void, glMultiTexCoord4xOES, (GLenum target, GLfixed s,
- GLfixed t, GLfixed r, GLfixed q))
+ GLfixed t, GLfixed r, GLfixed q))
_COREGL_EXT_SYMBOL(void, glNormal3xOES, (GLfixed nx, GLfixed ny, GLfixed nz))
_COREGL_EXT_SYMBOL(void, glOrthofOES, (GLfloat left, GLfloat right,
- GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
+ GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar))
_COREGL_EXT_SYMBOL(void, glOrthoxOES, (GLfixed left, GLfixed right,
- GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
+ GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar))
_COREGL_EXT_SYMBOL(void, glPointParameterxOES, (GLenum pname, GLfixed param))
_COREGL_EXT_SYMBOL(void, glPointParameterxvOES, (GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glPointSizexOES, (GLfixed size))
_COREGL_EXT_SYMBOL(void, glPolygonOffsetxOES, (GLfixed factor, GLfixed units))
_COREGL_EXT_SYMBOL(void, glQueryCounterEXT, (GLuint id, GLenum target))
_COREGL_EXT_SYMBOL(void, glRenderbufferStorageOES, (GLenum target,
- GLenum internalformat, GLsizei width, GLsizei height))
+ GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_EXT_SYMBOL(void, glRotatexOES, (GLfixed angle, GLfixed x, GLfixed y,
- GLfixed z))
+ GLfixed z))
_COREGL_EXT_SYMBOL(void, glSampleCoveragexOES, (GLclampx value,
- GLboolean invert))
+ GLboolean invert))
_COREGL_EXT_SYMBOL(void, glScalexOES, (GLfixed x, GLfixed y, GLfixed z))
_COREGL_EXT_SYMBOL(void, glTexEnvxOES, (GLenum target, GLenum pname,
- GLfixed param))
+ GLfixed param))
_COREGL_EXT_SYMBOL(void, glTexEnvxvOES, (GLenum target, GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glTexParameterxOES, (GLenum target, GLenum pname,
- GLfixed param))
+ GLfixed param))
_COREGL_EXT_SYMBOL(void, glTexParameterxvOES, (GLenum target, GLenum pname,
- const GLfixed *params))
+ const GLfixed *params))
_COREGL_EXT_SYMBOL(void, glTexStorage2DEXT, (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height))
+ GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_EXT_SYMBOL(void, glTexStorage3DEXT, (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))
_COREGL_EXT_SYMBOL(void, glTexStorage3DMultisampleOES, (GLenum target,
- GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height,
- GLsizei depth, GLboolean fixedsamplelocations))
+ GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height,
+ GLsizei depth, GLboolean fixedsamplelocations))
_COREGL_EXT_SYMBOL(void, glTranslatexOES, (GLfixed x, GLfixed y, GLfixed z))
-_COREGL_EXT_SYMBOL(void, glTexBufferOES, (GLenum target, GLenum internalformat, GLuint buffer))
-_COREGL_EXT_SYMBOL(void, glTexBufferEXT, (GLenum target, GLenum internalformat, GLuint buffer))
+_COREGL_EXT_SYMBOL(void, glTexBufferOES, (GLenum target, GLenum internalformat,
+ GLuint buffer))
+_COREGL_EXT_SYMBOL(void, glTexBufferEXT, (GLenum target, GLenum internalformat,
+ GLuint buffer))
_COREGL_END_API(COREGL_GLAPI_2)
/* OpenGL ES 3.0 */
_COREGL_START_API(COREGL_GLAPI_3)
_COREGL_SYMBOL(void, glReadBuffer, (GLenum mode))
_COREGL_SYMBOL(void, glDrawRangeElements, (GLenum mode, GLuint start,
- GLuint end, GLsizei count, GLenum type, const GLvoid *indices))
+ GLuint end, GLsizei count, GLenum type, const GLvoid *indices))
_COREGL_SYMBOL(void, glTexImage3D, (GLenum target, GLint level,
- GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLenum format, GLenum type, const GLvoid *pixels))
+ GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLenum format, GLenum type, const GLvoid *pixels))
_COREGL_SYMBOL(void, glTexSubImage3D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
- GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels))
+ GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
+ GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels))
_COREGL_SYMBOL(void, glCopyTexSubImage3D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width,
- GLsizei height))
+ GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width,
+ GLsizei height))
_COREGL_SYMBOL(void, glCompressedTexImage3D, (GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLsizei imageSize, const GLvoid *data))
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLsizei imageSize, const GLvoid *data))
_COREGL_SYMBOL(void, glCompressedTexSubImage3D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
- GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data))
+ GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
+ GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data))
_COREGL_SYMBOL(void, glGenQueries, (GLsizei n, GLuint *ids))
_COREGL_SYMBOL(void, glDeleteQueries, (GLsizei n, const GLuint *ids))
_COREGL_SYMBOL(GLboolean, glIsQuery, (GLuint id))
_COREGL_SYMBOL(void, glEndQuery, (GLenum target))
_COREGL_SYMBOL(void, glGetQueryiv, (GLenum target, GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetQueryObjectuiv, (GLuint id, GLenum pname,
- GLuint *params))
+ GLuint *params))
_COREGL_SYMBOL(GLboolean, glUnmapBuffer, (GLenum target))
_COREGL_SYMBOL(void, glGetBufferPointerv, (GLenum target, GLenum pname,
- GLvoid **params))
+ GLvoid **params))
_COREGL_SYMBOL(void, glDrawBuffers, (GLsizei n, const GLenum *bufs))
_COREGL_SYMBOL(void, glUniformMatrix2x3fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix3x2fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix2x4fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix4x2fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix3x4fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glUniformMatrix4x3fv, (GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value))
+ GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glBlitFramebuffer, (GLint srcX0, GLint srcY0, GLint srcX1,
- GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
- GLbitfield mask, GLenum filter))
+ GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+ GLbitfield mask, GLenum filter))
_COREGL_SYMBOL(void, glRenderbufferStorageMultisample, (GLenum target,
- GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
+ GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_SYMBOL(void, glFramebufferTextureLayer, (GLenum target,
- GLenum attachment, GLuint texture, GLint level, GLint layer))
+ GLenum attachment, GLuint texture, GLint level, GLint layer))
_COREGL_SYMBOL(GLvoid *, glMapBufferRange, (GLenum target, GLintptr offset,
- GLsizeiptr length, GLbitfield access))
+ GLsizeiptr length, GLbitfield access))
_COREGL_SYMBOL(void, glFlushMappedBufferRange, (GLenum target, GLintptr offset,
- GLsizeiptr length))
+ GLsizeiptr length))
_COREGL_SYMBOL(void, glBindVertexArray, (GLuint array))
_COREGL_SYMBOL(void, glDeleteVertexArrays, (GLsizei n, const GLuint *arrays))
_COREGL_SYMBOL(void, glGenVertexArrays, (GLsizei n, GLuint *arrays))
_COREGL_SYMBOL(GLboolean, glIsVertexArray, (GLuint array))
_COREGL_SYMBOL(void, glGetIntegeri_v, (GLenum target, GLuint index,
- GLint *data))
+ GLint *data))
_COREGL_SYMBOL(void, glBeginTransformFeedback, (GLenum primitiveMode))
_COREGL_SYMBOL(void, glEndTransformFeedback, (void))
_COREGL_SYMBOL(void, glBindBufferRange, (GLenum target, GLuint index,
- GLuint buffer, GLintptr offset, GLsizeiptr size))
+ GLuint buffer, GLintptr offset, GLsizeiptr size))
_COREGL_SYMBOL(void, glBindBufferBase, (GLenum target, GLuint index,
- GLuint buffer))
+ GLuint buffer))
_COREGL_SYMBOL(void, glTransformFeedbackVaryings, (GLuint program,
- GLsizei count, const GLchar *const *varyings, GLenum bufferMode))
+ GLsizei count, const GLchar *const *varyings, GLenum bufferMode))
_COREGL_SYMBOL(void, glGetTransformFeedbackVarying, (GLuint program,
- GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type,
- GLchar *name))
+ GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type,
+ GLchar *name))
_COREGL_SYMBOL(void, glVertexAttribIPointer, (GLuint index, GLint size,
- GLenum type, GLsizei stride, const GLvoid *pointer))
+ GLenum type, GLsizei stride, const GLvoid *pointer))
_COREGL_SYMBOL(void, glGetVertexAttribIiv, (GLuint index, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetVertexAttribIuiv, (GLuint index, GLenum pname,
- GLuint *params))
+ GLuint *params))
_COREGL_SYMBOL(void, glVertexAttribI4i, (GLuint index, GLint x, GLint y,
- GLint z, GLint w))
+ GLint z, GLint w))
_COREGL_SYMBOL(void, glVertexAttribI4ui, (GLuint index, GLuint x, GLuint y,
- GLuint z, GLuint w))
+ GLuint z, GLuint w))
_COREGL_SYMBOL(void, glVertexAttribI4iv, (GLuint index, const GLint *v))
_COREGL_SYMBOL(void, glVertexAttribI4uiv, (GLuint index, const GLuint *v))
_COREGL_SYMBOL(void, glGetUniformuiv, (GLuint program, GLint location,
- GLuint *params))
+ GLuint *params))
_COREGL_SYMBOL(GLint, glGetFragDataLocation, (GLuint program,
- const GLchar *name))
+ const GLchar *name))
_COREGL_SYMBOL(void, glUniform1ui, (GLint location, GLuint v0))
_COREGL_SYMBOL(void, glUniform2ui, (GLint location, GLuint v0, GLuint v1))
_COREGL_SYMBOL(void, glUniform3ui, (GLint location, GLuint v0, GLuint v1,
- GLuint v2))
+ GLuint v2))
_COREGL_SYMBOL(void, glUniform4ui, (GLint location, GLuint v0, GLuint v1,
- GLuint v2, GLuint v3))
+ GLuint v2, GLuint v3))
_COREGL_SYMBOL(void, glUniform1uiv, (GLint location, GLsizei count,
- const GLuint *value))
+ const GLuint *value))
_COREGL_SYMBOL(void, glUniform2uiv, (GLint location, GLsizei count,
- const GLuint *value))
+ const GLuint *value))
_COREGL_SYMBOL(void, glUniform3uiv, (GLint location, GLsizei count,
- const GLuint *value))
+ const GLuint *value))
_COREGL_SYMBOL(void, glUniform4uiv, (GLint location, GLsizei count,
- const GLuint *value))
+ const GLuint *value))
_COREGL_SYMBOL(void, glClearBufferiv, (GLenum buffer, GLint drawbuffer,
- const GLint *value))
+ const GLint *value))
_COREGL_SYMBOL(void, glClearBufferuiv, (GLenum buffer, GLint drawbuffer,
- const GLuint *value))
+ const GLuint *value))
_COREGL_SYMBOL(void, glClearBufferfv, (GLenum buffer, GLint drawbuffer,
- const GLfloat *value))
+ const GLfloat *value))
_COREGL_SYMBOL(void, glClearBufferfi, (GLenum buffer, GLint drawbuffer,
- GLfloat depth, GLint stencil))
+ GLfloat depth, GLint stencil))
_COREGL_SYMBOL(const GLubyte *, glGetStringi, (GLenum name, GLuint index))
_COREGL_SYMBOL(void, glCopyBufferSubData, (GLenum readTarget,
- GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size))
+ GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size))
_COREGL_SYMBOL(void, glGetUniformIndices, (GLuint program, GLsizei uniformCount,
- const GLchar *const *uniformNames, GLuint *uniformIndices))
+ const GLchar *const *uniformNames, GLuint *uniformIndices))
_COREGL_SYMBOL(void, glGetActiveUniformsiv, (GLuint program,
- GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname,
- GLint *params))
+ GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname,
+ GLint *params))
_COREGL_SYMBOL(GLuint, glGetUniformBlockIndex, (GLuint program,
- const GLchar *uniformBlockName))
+ const GLchar *uniformBlockName))
_COREGL_SYMBOL(void, glGetActiveUniformBlockiv, (GLuint program,
- GLuint uniformBlockIndex, GLenum pname, GLint *params))
+ GLuint uniformBlockIndex, GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetActiveUniformBlockName, (GLuint program,
- GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length,
- GLchar *uniformBlockName))
+ GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length,
+ GLchar *uniformBlockName))
_COREGL_SYMBOL(void, glUniformBlockBinding, (GLuint program,
- GLuint uniformBlockIndex, GLuint uniformBlockBinding))
+ GLuint uniformBlockIndex, GLuint uniformBlockBinding))
_COREGL_SYMBOL(void, glDrawArraysInstanced, (GLenum mode, GLint first,
- GLsizei count, GLsizei instanceCount))
+ GLsizei count, GLsizei instanceCount))
_COREGL_SYMBOL(void, glDrawElementsInstanced, (GLenum mode, GLsizei count,
- GLenum type, const GLvoid *indices, GLsizei instanceCount))
+ GLenum type, const GLvoid *indices, GLsizei instanceCount))
_COREGL_SYMBOL(GLsync, glFenceSync, (GLenum condition, GLbitfield flags))
_COREGL_SYMBOL(GLboolean, glIsSync, (GLsync sync))
_COREGL_SYMBOL(void, glDeleteSync, (GLsync sync))
_COREGL_SYMBOL(GLenum, glClientWaitSync, (GLsync sync, GLbitfield flags,
- GLuint64 timeout))
+ GLuint64 timeout))
_COREGL_SYMBOL(void, glWaitSync, (GLsync sync, GLbitfield flags,
- GLuint64 timeout))
+ GLuint64 timeout))
_COREGL_SYMBOL(void, glGetInteger64v, (GLenum pname, GLint64 *params))
_COREGL_SYMBOL(void, glGetSynciv, (GLsync sync, GLenum pname, GLsizei bufSize,
- GLsizei *length, GLint *values))
+ GLsizei *length, GLint *values))
_COREGL_SYMBOL(void, glGetInteger64i_v, (GLenum target, GLuint index,
- GLint64 *data))
+ GLint64 *data))
_COREGL_SYMBOL(void, glGetBufferParameteri64v, (GLenum target, GLenum pname,
- GLint64 *params))
+ GLint64 *params))
_COREGL_SYMBOL(void, glGenSamplers, (GLsizei n, GLuint *samplers))
_COREGL_SYMBOL(void, glDeleteSamplers, (GLsizei n, const GLuint *samplers))
_COREGL_SYMBOL(GLboolean, glIsSampler, (GLuint sampler))
_COREGL_SYMBOL(void, glBindSampler, (GLuint unit, GLuint sampler))
_COREGL_SYMBOL(void, glSamplerParameteri, (GLuint sampler, GLenum pname,
- GLint param))
+ GLint param))
_COREGL_SYMBOL(void, glSamplerParameteriv, (GLuint sampler, GLenum pname,
- const GLint *param))
+ const GLint *param))
_COREGL_SYMBOL(void, glSamplerParameterf, (GLuint sampler, GLenum pname,
- GLfloat param))
+ GLfloat param))
_COREGL_SYMBOL(void, glSamplerParameterfv, (GLuint sampler, GLenum pname,
- const GLfloat *param))
+ const GLfloat *param))
_COREGL_SYMBOL(void, glGetSamplerParameteriv, (GLuint sampler, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGetSamplerParameterfv, (GLuint sampler, GLenum pname,
- GLfloat *params))
+ GLfloat *params))
_COREGL_SYMBOL(void, glVertexAttribDivisor, (GLuint index, GLuint divisor))
_COREGL_SYMBOL(void, glBindTransformFeedback, (GLenum target, GLuint id))
_COREGL_SYMBOL(void, glDeleteTransformFeedbacks, (GLsizei n, const GLuint *ids))
_COREGL_SYMBOL(void, glPauseTransformFeedback, (void))
_COREGL_SYMBOL(void, glResumeTransformFeedback, (void))
_COREGL_SYMBOL(void, glGetProgramBinary, (GLuint program, GLsizei bufSize,
- GLsizei *length, GLenum *binaryFormat, GLvoid *binary))
+ GLsizei *length, GLenum *binaryFormat, GLvoid *binary))
_COREGL_SYMBOL(void, glProgramBinary, (GLuint program, GLenum binaryFormat,
- const GLvoid *binary, GLsizei length))
+ const GLvoid *binary, GLsizei length))
_COREGL_SYMBOL(void, glProgramParameteri, (GLuint program, GLenum pname,
- GLint value))
+ GLint value))
_COREGL_SYMBOL(void, glInvalidateFramebuffer, (GLenum target,
- GLsizei numAttachments, const GLenum *attachments))
+ GLsizei numAttachments, const GLenum *attachments))
_COREGL_SYMBOL(void, glInvalidateSubFramebuffer, (GLenum target,
- GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y,
- GLsizei width, GLsizei height))
+ GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y,
+ GLsizei width, GLsizei height))
_COREGL_SYMBOL(void, glTexStorage2D, (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height))
+ GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_SYMBOL(void, glTexStorage3D, (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))
_COREGL_SYMBOL(void, glGetInternalformativ, (GLenum target,
- GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params))
+ GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params))
_COREGL_END_API(COREGL_GLAPI_3)
/* OpenGL ES 3.1 */
_COREGL_START_API(COREGL_GLAPI_31)
_COREGL_SYMBOL(GLuint, glCreateShaderProgramv, (GLenum type, GLsizei count,
- const GLchar *const *strings))
+ const GLchar *const *strings))
_COREGL_SYMBOL(void, glGenProgramPipelines, (GLsizei n, GLuint *pipelines))
_COREGL_SYMBOL(void, glBindProgramPipeline, (GLuint pipeline))
_COREGL_SYMBOL(void, glGetProgramPipelineiv, (GLuint pipeline, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glDeleteProgramPipelines, (GLsizei n,
- GLuint const *pipelines))
+ GLuint const *pipelines))
_COREGL_SYMBOL(GLboolean, glIsProgramPipeline, (GLuint pipeline))
_COREGL_SYMBOL(void, glValidateProgramPipeline, (GLuint pipeline))
_COREGL_SYMBOL(void, glGetProgramPipelineInfoLog, (GLuint pipeline,
- GLsizei bufSize, GLsizei *length, GLchar *infoLog))
+ GLsizei bufSize, GLsizei *length, GLchar *infoLog))
_COREGL_SYMBOL(void, glDispatchCompute, (GLuint num_groups_x,
- GLuint num_groups_y, GLuint num_groups_z))
+ GLuint num_groups_y, GLuint num_groups_z))
_COREGL_SYMBOL(void, glDispatchComputeIndirect, (GLintptr indirect))
_COREGL_SYMBOL(void, glDrawArraysIndirect, (GLenum mode,
- GLvoid const *indirect))
+ GLvoid const *indirect))
_COREGL_SYMBOL(void, glDrawElementsIndirect, (GLenum mode, GLenum type,
- GLvoid const *indirect))
+ GLvoid const *indirect))
_COREGL_SYMBOL(void, glFramebufferParameteri, (GLenum target, GLenum pname,
- GLint param))
+ GLint param))
_COREGL_SYMBOL(void, glGetFramebufferParameteriv, ( GLenum target,
- GLenum pname, GLint *params))
+ GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetProgramInterfaceiv, (GLuint program,
- GLenum programInterface, GLenum pname, GLint *params))
+ GLenum programInterface, GLenum pname, GLint *params))
_COREGL_SYMBOL(GLuint, glGetProgramResourceIndex, (GLuint program,
- GLenum programInterface, const char *name))
+ GLenum programInterface, const char *name))
_COREGL_SYMBOL(void, glGetProgramResourceName, (GLuint program,
- GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length,
- GLchar *name))
+ GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length,
+ GLchar *name))
_COREGL_SYMBOL(void, glGetProgramResourceiv, (GLuint program,
- GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props,
- GLsizei bufSize, GLsizei *length, GLint *params))
+ GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props,
+ GLsizei bufSize, GLsizei *length, GLint *params))
_COREGL_SYMBOL(GLint, glGetProgramResourceLocation, (GLuint program,
- GLenum programInterface, GLchar const *name))
+ GLenum programInterface, GLchar const *name))
_COREGL_SYMBOL(void, glUseProgramStages, (GLuint pipeline, GLbitfield stages,
- GLuint program))
+ GLuint program))
_COREGL_SYMBOL(void, glActiveShaderProgram, (GLuint pipeline, GLuint program))
_COREGL_SYMBOL(void, glProgramUniform1iv, (GLuint program, GLint location,
- GLsizei count, const GLint *value))
+ GLsizei count, const GLint *value))
_COREGL_SYMBOL(void, glProgramUniform2iv, (GLuint program, GLint location,
- GLsizei count, const GLint *value))
+ GLsizei count, const GLint *value))
_COREGL_SYMBOL(void, glProgramUniform3iv, (GLuint program, GLint location,
- GLsizei count, const GLint *value))
+ GLsizei count, const GLint *value))
_COREGL_SYMBOL(void, glProgramUniform4iv, (GLuint program, GLint location,
- GLsizei count, const GLint *value))
+ GLsizei count, const GLint *value))
_COREGL_SYMBOL(void, glProgramUniform1fv, (GLuint program, GLint location,
- GLsizei count, const GLfloat *value))
+ GLsizei count, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniform2fv, (GLuint program, GLint location,
- GLsizei count, const GLfloat *value))
+ GLsizei count, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniform3fv, (GLuint program, GLint location,
- GLsizei count, const GLfloat *value))
+ GLsizei count, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniform4fv, (GLuint program, GLint location,
- GLsizei count, const GLfloat *value))
+ GLsizei count, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix2fv, (GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix3fv, (GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix4fv, (GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniform1i, (GLuint program, GLint location,
- GLint x))
+ GLint x))
_COREGL_SYMBOL(void, glProgramUniform2i, (GLuint program, GLint location,
- GLint x, GLint y))
+ GLint x, GLint y))
_COREGL_SYMBOL(void, glProgramUniform3i, (GLuint program, GLint location,
- GLint x, GLint y, GLint z))
+ GLint x, GLint y, GLint z))
_COREGL_SYMBOL(void, glProgramUniform4i, (GLuint program, GLint location,
- GLint x, GLint y, GLint z, GLint w))
+ GLint x, GLint y, GLint z, GLint w))
_COREGL_SYMBOL(void, glProgramUniform1f, (GLuint program, GLint location,
- GLfloat x))
+ GLfloat x))
_COREGL_SYMBOL(void, glProgramUniform2f, (GLuint program, GLint location,
- GLfloat x, GLfloat y))
+ GLfloat x, GLfloat y))
_COREGL_SYMBOL(void, glProgramUniform3f, (GLuint program, GLint location,
- GLfloat x, GLfloat y, GLfloat z))
+ GLfloat x, GLfloat y, GLfloat z))
_COREGL_SYMBOL(void, glProgramUniform4f, (GLuint program, GLint location,
- GLfloat x, GLfloat y, GLfloat z, GLfloat w))
+ GLfloat x, GLfloat y, GLfloat z, GLfloat w))
_COREGL_SYMBOL(void, glProgramUniform1ui, (GLuint program, GLint location,
- GLuint x))
+ GLuint x))
_COREGL_SYMBOL(void, glProgramUniform2ui, (GLuint program, GLint location,
- GLuint x, GLuint y))
+ GLuint x, GLuint y))
_COREGL_SYMBOL(void, glProgramUniform3ui, (GLuint program, GLint location,
- GLuint x, GLuint y, GLuint z))
+ GLuint x, GLuint y, GLuint z))
_COREGL_SYMBOL(void, glProgramUniform4ui, (GLuint program, GLint location,
- GLuint x, GLuint y, GLuint z, GLuint w))
+ GLuint x, GLuint y, GLuint z, GLuint w))
_COREGL_SYMBOL(void, glProgramUniform1uiv, (GLuint program, GLint location,
- GLsizei count, const GLuint *value))
+ GLsizei count, const GLuint *value))
_COREGL_SYMBOL(void, glProgramUniform2uiv, (GLuint program, GLint location,
- GLsizei count, const GLuint *value))
+ GLsizei count, const GLuint *value))
_COREGL_SYMBOL(void, glProgramUniform3uiv, (GLuint program, GLint location,
- GLsizei count, const GLuint *value))
+ GLsizei count, const GLuint *value))
_COREGL_SYMBOL(void, glProgramUniform4uiv, (GLuint program, GLint location,
- GLsizei count, const GLuint *value))
+ GLsizei count, const GLuint *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix2x3fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix3x2fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix4x2fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix2x4fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix3x4fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glProgramUniformMatrix4x3fv, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_SYMBOL(void, glBindImageTexture, (GLuint unit, GLuint texture,
- GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format))
+ GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format))
_COREGL_SYMBOL(void, glGetBooleani_v, (GLenum target, GLuint index,
- GLboolean *data))
+ GLboolean *data))
_COREGL_SYMBOL(void, glMemoryBarrier, (GLbitfield barriers))
_COREGL_SYMBOL(void, glMemoryBarrierByRegion, (GLbitfield barriers))
_COREGL_SYMBOL(void, glTexStorage2DMultisample, (GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height,
- GLboolean fixedsamplelocations))
+ GLenum internalformat, GLsizei width, GLsizei height,
+ GLboolean fixedsamplelocations))
_COREGL_SYMBOL(void, glGetMultisamplefv, (GLenum pname, GLuint index,
- GLfloat *val))
+ GLfloat *val))
_COREGL_SYMBOL(void, glSampleMaski, (GLuint maskNumber, GLbitfield mask))
_COREGL_SYMBOL(void, glGetTexLevelParameteriv, (GLenum target, GLint level,
- GLenum pname, GLint *params))
+ GLenum pname, GLint *params))
_COREGL_SYMBOL(void, glGetTexLevelParameterfv, (GLenum target, GLint level,
- GLenum pname, GLfloat *params))
+ GLenum pname, GLfloat *params))
_COREGL_SYMBOL(void, glBindVertexBuffer, (GLuint bindingindex, GLuint buffer,
- GLintptr offset, GLsizei stride))
+ GLintptr offset, GLsizei stride))
_COREGL_SYMBOL(void, glVertexAttribFormat, (GLuint attribindex, GLint size,
- GLenum type, GLboolean normalized, GLuint relativeoffset))
+ GLenum type, GLboolean normalized, GLuint relativeoffset))
_COREGL_SYMBOL(void, glVertexAttribIFormat, (GLuint attribindex, GLint size,
- GLenum type, GLuint relativeoffset))
+ GLenum type, GLuint relativeoffset))
_COREGL_SYMBOL(void, glVertexAttribBinding, (GLuint attribindex,
- GLuint bindingindex))
+ GLuint bindingindex))
_COREGL_SYMBOL(void, glVertexBindingDivisor, (GLuint bindingindex,
- GLuint divisor))
+ GLuint divisor))
_COREGL_END_API(COREGL_GLAPI_31)
/* OpenGL ES 3.2 */
_COREGL_START_API(COREGL_GLAPI_32)
_COREGL_SYMBOL(void, glBlendBarrier, (void))
_COREGL_SYMBOL(void, glCopyImageSubData, (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))
+ 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))
_COREGL_SYMBOL(void, glDebugMessageControl, (GLenum source, GLenum type,
- GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled))
+ GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled))
_COREGL_SYMBOL(void, glDebugMessageInsert, (GLenum source, GLenum type,
- GLuint id, GLenum severity, GLsizei length, const GLchar *buf))
-_COREGL_SYMBOL(void, glDebugMessageCallback, (GLDEBUGPROC callback, const void *userParam))
+ GLuint id, GLenum severity, GLsizei length, const GLchar *buf))
+_COREGL_SYMBOL(void, glDebugMessageCallback, (GLDEBUGPROC callback,
+ const void *userParam))
_COREGL_SYMBOL(GLuint, glGetDebugMessageLog, (GLuint count, GLsizei bufSize,
- GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities,
- GLsizei *lengths, GLchar *messageLog))
-_COREGL_SYMBOL(void, glPushDebugGroup, (GLenum source, GLuint id, GLsizei length,
- const GLchar *message))
+ GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities,
+ GLsizei *lengths, GLchar *messageLog))
+_COREGL_SYMBOL(void, glPushDebugGroup, (GLenum source, GLuint id,
+ GLsizei length,
+ const GLchar *message))
_COREGL_SYMBOL(void, glPopDebugGroup, (void))
_COREGL_SYMBOL(void, glObjectLabel, (GLenum identifier, GLuint name,
- GLsizei length, const GLchar *label))
+ GLsizei length, const GLchar *label))
_COREGL_SYMBOL(void, glGetObjectLabel, (GLenum identifier, GLuint name,
- GLsizei bufSize, GLsizei *length, GLchar *label))
+ GLsizei bufSize, GLsizei *length, GLchar *label))
_COREGL_SYMBOL(void, glObjectPtrLabel, (const void *ptr, GLsizei length,
- const GLchar *label))
+ const GLchar *label))
_COREGL_SYMBOL(void, glGetObjectPtrLabel, (const void *ptr, GLsizei bufSize,
- GLsizei *length, GLchar *label))
+ GLsizei *length, GLchar *label))
_COREGL_SYMBOL(void, glEnablei, (GLenum target, GLuint index))
_COREGL_SYMBOL(void, glDisablei, (GLenum target, GLuint index))
_COREGL_SYMBOL(void, glBlendEquationi, (GLuint buf, GLenum mode))
_COREGL_SYMBOL(void, glBlendEquationSeparatei, (GLuint buf, GLenum modeRGB,
- GLenum modeAlpha))
+ GLenum modeAlpha))
_COREGL_SYMBOL(void, glBlendFunci, (GLuint buf, GLenum src, GLenum dst))
-_COREGL_SYMBOL(void, glBlendFuncSeparatei, (GLuint buf, GLenum srcRGB, GLenum dstRGB,
- GLenum srcAlpha, GLenum dstAlpha))
-_COREGL_SYMBOL(void, glColorMaski, (GLuint index, GLboolean r, GLboolean g, GLboolean b,
- GLboolean a))
+_COREGL_SYMBOL(void, glBlendFuncSeparatei, (GLuint buf, GLenum srcRGB,
+ GLenum dstRGB,
+ GLenum srcAlpha, GLenum dstAlpha))
+_COREGL_SYMBOL(void, glColorMaski, (GLuint index, GLboolean r, GLboolean g,
+ GLboolean b,
+ GLboolean a))
_COREGL_SYMBOL(GLboolean, glIsEnabledi, (GLenum target, GLuint index))
-_COREGL_SYMBOL(void, glDrawElementsBaseVertex, (GLenum mode, GLsizei count, GLenum type,
- const void *indices, GLint basevertex))
-_COREGL_SYMBOL(void, glDrawRangeElementsBaseVertex, (GLenum mode, GLuint start, GLuint end,
- GLsizei count, GLenum type, const void *indices, GLint basevertex))
-_COREGL_SYMBOL(void, glDrawElementsInstancedBaseVertex, (GLenum mode, GLsizei count, GLenum type,
- const void *indices, GLsizei instancecount, GLint basevertex))
-_COREGL_SYMBOL(void, glFramebufferTexture, (GLenum target, GLenum attachment, GLuint texture,
- GLint level))
-_COREGL_SYMBOL(void, glPrimitiveBoundingBox, (GLfloat minX, GLfloat minY, GLfloat minZ,
- GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW))
+_COREGL_SYMBOL(void, glDrawElementsBaseVertex, (GLenum mode, GLsizei count,
+ GLenum type,
+ const void *indices, GLint basevertex))
+_COREGL_SYMBOL(void, glDrawRangeElementsBaseVertex, (GLenum mode, GLuint start,
+ GLuint end,
+ GLsizei count, GLenum type, const void *indices, GLint basevertex))
+_COREGL_SYMBOL(void, glDrawElementsInstancedBaseVertex, (GLenum mode,
+ GLsizei count, GLenum type,
+ const void *indices, GLsizei instancecount, GLint basevertex))
+_COREGL_SYMBOL(void, glFramebufferTexture, (GLenum target, GLenum attachment,
+ GLuint texture,
+ GLint level))
+_COREGL_SYMBOL(void, glPrimitiveBoundingBox, (GLfloat minX, GLfloat minY,
+ GLfloat minZ,
+ GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW))
_COREGL_SYMBOL(GLenum, glGetGraphicsResetStatus, (void))
-_COREGL_SYMBOL(void, glReadnPixels, (GLint x, GLint y, GLsizei width, GLsizei height,
- GLenum format, GLenum type, GLsizei bufSize, void *data))
-_COREGL_SYMBOL(void, glGetnUniformfv, (GLuint program, GLint location, GLsizei bufSize, GLfloat *params))
-_COREGL_SYMBOL(void, glGetnUniformiv, (GLuint program, GLint location, GLsizei bufSize, GLint *params))
-_COREGL_SYMBOL(void, glGetnUniformuiv, (GLuint program, GLint location, GLsizei bufSize, GLuint *params))
+_COREGL_SYMBOL(void, glReadnPixels, (GLint x, GLint y, GLsizei width,
+ GLsizei height,
+ GLenum format, GLenum type, GLsizei bufSize, void *data))
+_COREGL_SYMBOL(void, glGetnUniformfv, (GLuint program, GLint location,
+ GLsizei bufSize, GLfloat *params))
+_COREGL_SYMBOL(void, glGetnUniformiv, (GLuint program, GLint location,
+ GLsizei bufSize, GLint *params))
+_COREGL_SYMBOL(void, glGetnUniformuiv, (GLuint program, GLint location,
+ GLsizei bufSize, GLuint *params))
_COREGL_SYMBOL(void, glMinSampleShading, (GLfloat value))
_COREGL_SYMBOL(void, glPatchParameteri, (GLenum pname, GLint value))
-_COREGL_SYMBOL(void, glTexParameterIiv, (GLenum target, GLenum pname, const GLint *params))
-_COREGL_SYMBOL(void, glTexParameterIuiv, (GLenum target, GLenum pname, const GLuint *params))
-_COREGL_SYMBOL(void, glGetTexParameterIiv, (GLenum target, GLenum pname, GLint *params))
-_COREGL_SYMBOL(void, glGetTexParameterIuiv, (GLenum target, GLenum pname, GLuint *params))
-_COREGL_SYMBOL(void, glSamplerParameterIiv, (GLuint sampler, GLenum pname, const GLint *param))
-_COREGL_SYMBOL(void, glSamplerParameterIuiv, (GLuint sampler, GLenum pname, const GLuint *param))
-_COREGL_SYMBOL(void, glGetSamplerParameterIiv, (GLuint sampler, GLenum pname, GLint *params))
-_COREGL_SYMBOL(void, glGetSamplerParameterIuiv, (GLuint sampler, GLenum pname, GLuint *params))
-_COREGL_SYMBOL(void, glTexBuffer, (GLenum target, GLenum internalformat, GLuint buffer))
-_COREGL_SYMBOL(void, glTexBufferRange, (GLenum target, GLenum internalformat, GLuint buffer,
- GLintptr offset, GLsizeiptr size))
-_COREGL_SYMBOL(void, glTexStorage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat,
- GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations))
+_COREGL_SYMBOL(void, glTexParameterIiv, (GLenum target, GLenum pname,
+ const GLint *params))
+_COREGL_SYMBOL(void, glTexParameterIuiv, (GLenum target, GLenum pname,
+ const GLuint *params))
+_COREGL_SYMBOL(void, glGetTexParameterIiv, (GLenum target, GLenum pname,
+ GLint *params))
+_COREGL_SYMBOL(void, glGetTexParameterIuiv, (GLenum target, GLenum pname,
+ GLuint *params))
+_COREGL_SYMBOL(void, glSamplerParameterIiv, (GLuint sampler, GLenum pname,
+ const GLint *param))
+_COREGL_SYMBOL(void, glSamplerParameterIuiv, (GLuint sampler, GLenum pname,
+ const GLuint *param))
+_COREGL_SYMBOL(void, glGetSamplerParameterIiv, (GLuint sampler, GLenum pname,
+ GLint *params))
+_COREGL_SYMBOL(void, glGetSamplerParameterIuiv, (GLuint sampler, GLenum pname,
+ GLuint *params))
+_COREGL_SYMBOL(void, glTexBuffer, (GLenum target, GLenum internalformat,
+ GLuint buffer))
+_COREGL_SYMBOL(void, glTexBufferRange, (GLenum target, GLenum internalformat,
+ GLuint buffer,
+ GLintptr offset, GLsizeiptr size))
+_COREGL_SYMBOL(void, glTexStorage3DMultisample, (GLenum target, GLsizei samples,
+ GLenum internalformat,
+ GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations))
_COREGL_END_API(COREGL_GLAPI_32)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_EGL_image", 1.1, -1)
_COREGL_EXT_SYMBOL(void, glEGLImageTargetTexture2DOES, (GLenum target,
- GLeglImageOES image))
+ GLeglImageOES image))
_COREGL_EXT_SYMBOL(void, glEGLImageTargetRenderbufferStorageOES, (GLenum target,
- GLeglImageOES image))
+ GLeglImageOES image))
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_EGL_image_external", 1.1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_surfaceless_context", 1.1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_fixed_point", 1.1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_get_program_binary", 2.0, -1)
_COREGL_EXT_SYMBOL(void, glGetProgramBinaryOES, (GLuint program,
- GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary))
+ GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary))
_COREGL_EXT_SYMBOL(void, glProgramBinaryOES, (GLuint program,
- GLenum binaryFormat, const GLvoid *binary, GLsizei length))
+ GLenum binaryFormat, const GLvoid *binary, GLsizei length))
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_AMD_program_binary_Z400", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_IMG_program_binary ", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_separate_shader_objects", 2.0, -1)
_COREGL_EXT_SYMBOL(void, glUseProgramStagesEXT, (GLuint pipeline,
- GLbitfield stages, GLuint program))
+ GLbitfield stages, GLuint program))
_COREGL_EXT_SYMBOL(void, glActiveShaderProgramEXT, (GLuint pipeline,
- GLuint program))
+ GLuint program))
_COREGL_EXT_SYMBOL(GLuint, glCreateShaderProgramvEXT, (GLenum type,
- GLsizei count, const char **strings))
+ GLsizei count, const char **strings))
_COREGL_EXT_SYMBOL(void, glBindProgramPipelineEXT, (GLuint pipeline))
_COREGL_EXT_SYMBOL(void, glDeleteProgramPipelinesEXT, (GLsizei n,
- const GLuint *pipelines))
+ const GLuint *pipelines))
_COREGL_EXT_SYMBOL(void, glGenProgramPipelinesEXT, (GLsizei n,
- GLuint *pipelines))
+ GLuint *pipelines))
_COREGL_EXT_SYMBOL(GLboolean, glIsProgramPipelineEXT, (GLuint pipeline))
_COREGL_EXT_SYMBOL(void, glProgramParameteriEXT, (GLuint program, GLenum pname,
- GLint value))
+ GLint value))
_COREGL_EXT_SYMBOL(void, glGetProgramPipelineivEXT, (GLuint pipeline,
- GLenum pname, GLint *params))
+ GLenum pname, GLint *params))
_COREGL_EXT_SYMBOL(void, glProgramUniform1iEXT, (GLuint program, GLint location,
- GLint x))
+ GLint x))
_COREGL_EXT_SYMBOL(void, glProgramUniform2iEXT, (GLuint program, GLint location,
- GLint x, GLint y))
+ GLint x, GLint y))
_COREGL_EXT_SYMBOL(void, glProgramUniform3iEXT, (GLuint program, GLint location,
- GLint x, GLint y, GLint z))
+ GLint x, GLint y, GLint z))
_COREGL_EXT_SYMBOL(void, glProgramUniform4iEXT, (GLuint program, GLint location,
- GLint x, GLint y, GLint z, GLint w))
+ GLint x, GLint y, GLint z, GLint w))
_COREGL_EXT_SYMBOL(void, glProgramUniform1fEXT, (GLuint program, GLint location,
- GLfloat x))
+ GLfloat x))
_COREGL_EXT_SYMBOL(void, glProgramUniform2fEXT, (GLuint program, GLint location,
- GLfloat x, GLfloat y))
+ GLfloat x, GLfloat y))
_COREGL_EXT_SYMBOL(void, glProgramUniform3fEXT, (GLuint program, GLint location,
- GLfloat x, GLfloat y, GLfloat z))
+ GLfloat x, GLfloat y, GLfloat z))
_COREGL_EXT_SYMBOL(void, glProgramUniform4fEXT, (GLuint program, GLint location,
- GLfloat x, GLfloat y, GLfloat z, GLfloat w))
+ GLfloat x, GLfloat y, GLfloat z, GLfloat w))
_COREGL_EXT_SYMBOL(void, glProgramUniform1ivEXT, (GLuint program,
- GLint location, GLsizei count, const GLint *value))
+ GLint location, GLsizei count, const GLint *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform2ivEXT, (GLuint program,
- GLint location, GLsizei count, const GLint *value))
+ GLint location, GLsizei count, const GLint *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform3ivEXT, (GLuint program,
- GLint location, GLsizei count, const GLint *value))
+ GLint location, GLsizei count, const GLint *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform4ivEXT, (GLuint program,
- GLint location, GLsizei count, const GLint *value))
+ GLint location, GLsizei count, const GLint *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform1fvEXT, (GLuint program,
- GLint location, GLsizei count, const GLfloat *value))
+ GLint location, GLsizei count, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform2fvEXT, (GLuint program,
- GLint location, GLsizei count, const GLfloat *value))
+ GLint location, GLsizei count, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform3fvEXT, (GLuint program,
- GLint location, GLsizei count, const GLfloat *value))
+ GLint location, GLsizei count, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniform4fvEXT, (GLuint program,
- GLint location, GLsizei count, const GLfloat *value))
+ GLint location, GLsizei count, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniformMatrix2fvEXT, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniformMatrix3fvEXT, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glProgramUniformMatrix4fvEXT, (GLuint program,
- GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
+ GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))
_COREGL_EXT_SYMBOL(void, glValidateProgramPipelineEXT, (GLuint pipeline))
_COREGL_EXT_SYMBOL(void, glGetProgramPipelineInfoLogEXT, (GLuint pipeline,
- GLsizei bufSize, GLsizei *length, char *infoLog))
+ GLsizei bufSize, GLsizei *length, char *infoLog))
_COREGL_EXT_SYMBOL(void, glGetQueryObjecti64vEXT, (GLuint id, GLenum pname,
- GLint64 *params))
+ GLint64 *params))
_COREGL_EXT_SYMBOL(void, glGetQueryObjectivEXT, (GLuint id, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_EXT_SYMBOL(void, glGetQueryObjectui64vEXT, (GLuint id, GLenum pname,
- GLuint64 *params))
+ GLuint64 *params))
_COREGL_EXT_SYMBOL(void, glGetQueryObjectuivEXT, (GLuint id, GLenum pname,
- GLuint *params))
+ GLuint *params))
_COREGL_EXT_SYMBOL(void, glGetQueryivEXT, (GLenum target, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_EXT_SYMBOL(void, glBeginQueryEXT, (GLenum target, GLuint id))
_COREGL_EXT_SYMBOL(void, glDeleteQueriesEXT, (GLsizei n, const GLuint *ids))
_COREGL_EXT_SYMBOL(void, glGenQueriesEXT, (GLsizei n, GLuint *ids))
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_3D", 2.0, -1)
_COREGL_EXT_SYMBOL(void, glTexImage3DOES, (GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLenum format, GLenum type, const void *pixels))
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLenum format, GLenum type, const void *pixels))
_COREGL_EXT_SYMBOL(void, glTexSubImage3DOES, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
- GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels))
+ GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
+ GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels))
_COREGL_EXT_SYMBOL(void, glCopyTexSubImage3DOES, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width,
- GLsizei height))
+ GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width,
+ GLsizei height))
_COREGL_EXT_SYMBOL(void, glCompressedTexImage3DOES, (GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLsizei imageSize, const GLvoid *data))
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLsizei imageSize, const GLvoid *data))
_COREGL_EXT_SYMBOL(void, glCompressedTexSubImage3DOES, (GLenum target,
- GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
- GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
- const GLvoid *data))
+ GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
+ GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
+ const GLvoid *data))
/*
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_ANGLE_framebuffer_blit", 1.1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_ARM_mali_shader_binary", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_compressed_ETC1_RGB8_texture", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_compressed_paletted_texture", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_AMD_compressed_3DC_texture", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_AMD_compressed_ATC_texture", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_compression_dxt1", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_IMG_texture_compression_pvrtc", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_texture_compression_s3tc_update",
- -1, -1)
+ -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_ANGLE_texture_compression_dxt3", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_ANGLE_texture_compression_dxt5", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_KHR_texture_compression_astc_ldr", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_texture_compression_s3tc", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_texture_compression_latc", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_IMG_texture_compression_pvrtc2", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_type_2_10_10_10_REV", -1,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_format_BGRA8888", -1, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_APPLE_texture_format_BGRA8888", 1.0,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_half_float_linear", 2.0,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_float_linear", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_half_float", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_float", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_npot", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_IMG_texture_env_enhanced_fixed_function",
- 1.0, -1)
+ 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_APPLE_texture_max_level", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_texture_npot_2D_mipmap", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_ANGLE_texture_usage", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_sRGB", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_sRGB_decode", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_filter_anisotropic", 1.2,
- -1)
+ -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_standard_derivatives", 2.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_depth24", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_buffer", 2.0, -1)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glTexBufferRangeOES)
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_internalformat_sample_query", 2.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_internalformat_sample_query", 2.0,
+ -1)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glGetInternalformatSampleivNV)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_draw_buffers_indexed", 2.0, -1)
_COREGL_START_API(COREGL_GLAPI_1_2_COMMON)
_COREGL_SYMBOL(void, glActiveTexture, (GLenum texture))
-_COREGL_SYMBOL(void, glClearColor, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha))
+_COREGL_SYMBOL(void, glClearColor, (GLclampf red, GLclampf green, GLclampf blue,
+ GLclampf alpha))
_COREGL_SYMBOL(void, glClearDepthf, (GLclampf depth))
_COREGL_SYMBOL(void, glDepthRangef, (GLclampf zNear, GLclampf zFar))
_COREGL_SYMBOL(void, glGetFloatv, (GLenum pname, GLfloat *params))
-_COREGL_SYMBOL(void, glGetTexParameterfv, (GLenum target, GLenum pname, GLfloat *params))
+_COREGL_SYMBOL(void, glGetTexParameterfv, (GLenum target, GLenum pname,
+ GLfloat *params))
_COREGL_SYMBOL(void, glLineWidth, (GLfloat width))
_COREGL_SYMBOL(void, glPolygonOffset, (GLfloat factor, GLfloat units))
-_COREGL_SYMBOL(void, glTexParameterf, (GLenum target, GLenum pname, GLfloat param))
-_COREGL_SYMBOL(void, glTexParameterfv, (GLenum target, GLenum pname, const GLfloat *params))
+_COREGL_SYMBOL(void, glTexParameterf, (GLenum target, GLenum pname,
+ GLfloat param))
+_COREGL_SYMBOL(void, glTexParameterfv, (GLenum target, GLenum pname,
+ const GLfloat *params))
_COREGL_SYMBOL(void, glBindBuffer, (GLenum target, GLuint buffer))
_COREGL_SYMBOL(void, glBindTexture, (GLenum target, GLuint texture))
_COREGL_SYMBOL(void, glBlendFunc, (GLenum sfactor, GLenum dfactor))
_COREGL_SYMBOL(void, glBufferData, (GLenum target, GLsizeiptr size,
- const void *data, GLenum usage))
+ const void *data, GLenum usage))
_COREGL_SYMBOL(void, glBufferSubData, (GLenum target, GLintptr offset,
- GLsizeiptr size, const void *data))
+ GLsizeiptr size, const void *data))
_COREGL_SYMBOL(void, glClear, (GLbitfield mask))
_COREGL_SYMBOL(void, glClearStencil, (GLint s))
_COREGL_SYMBOL(void, glColorMask, (GLboolean red, GLboolean green,
- GLboolean blue, GLboolean alpha))
+ GLboolean blue, GLboolean alpha))
_COREGL_SYMBOL(void, glCompressedTexImage2D, (GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLint border,
- GLsizei imageSize, const void *data))
+ GLenum internalformat, GLsizei width, GLsizei height, GLint border,
+ GLsizei imageSize, const void *data))
_COREGL_SYMBOL(void, glCompressedTexSubImage2D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
- GLsizei imageSize, const void *data))
+ GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+ GLsizei imageSize, const void *data))
_COREGL_SYMBOL(void, glCopyTexImage2D, (GLenum target, GLint level,
- GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border))
+ GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height,
+ GLint border))
_COREGL_SYMBOL(void, glCopyTexSubImage2D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height))
+ GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height))
_COREGL_SYMBOL(void, glCullFace, (GLenum mode))
_COREGL_SYMBOL(void, glDeleteBuffers, (GLsizei n, const GLuint *buffers))
_COREGL_SYMBOL(void, glDeleteTextures, (GLsizei n, const GLuint *textures))
_COREGL_SYMBOL(void, glDisable, (GLenum cap))
_COREGL_SYMBOL(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count))
_COREGL_SYMBOL(void, glDrawElements, (GLenum mode, GLsizei count, GLenum type,
- const void *indices))
+ const void *indices))
_COREGL_SYMBOL(void, glEnable, (GLenum cap))
_COREGL_SYMBOL(void, glFinish, (void))
_COREGL_SYMBOL(void, glFlush, (void))
_COREGL_SYMBOL(void, glFrontFace, (GLenum mode))
_COREGL_SYMBOL(void, glGetBooleanv, (GLenum pname, GLboolean *params))
_COREGL_SYMBOL(void, glGetBufferParameteriv, (GLenum target, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glGenBuffers, (GLsizei n, GLuint *buffers))
_COREGL_SYMBOL(void, glGenTextures, (GLsizei n, GLuint *textures))
_COREGL_SYMBOL(GLenum, glGetError, (void))
_COREGL_SYMBOL(void, glGetPointerv, (GLenum pname, GLvoid **params))
_COREGL_SYMBOL(const GLubyte *, glGetString, (GLenum name))
_COREGL_SYMBOL(void, glGetTexParameteriv, (GLenum target, GLenum pname,
- GLint *params))
+ GLint *params))
_COREGL_SYMBOL(void, glHint, (GLenum target, GLenum mode))
_COREGL_SYMBOL(GLboolean, glIsBuffer, (GLuint buffer))
_COREGL_SYMBOL(GLboolean, glIsEnabled, (GLenum cap))
_COREGL_SYMBOL(GLboolean, glIsTexture, (GLuint texture))
_COREGL_SYMBOL(void, glPixelStorei, (GLenum pname, GLint param))
_COREGL_SYMBOL(void, glReadPixels, (GLint x, GLint y, GLsizei width,
- GLsizei height, GLenum format, GLenum type, void *pixels))
+ GLsizei height, GLenum format, GLenum type, void *pixels))
_COREGL_SYMBOL(void, glSampleCoverage, (GLclampf value, GLboolean invert))
_COREGL_SYMBOL(void, glScissor, (GLint x, GLint y, GLsizei width,
- GLsizei height))
+ GLsizei height))
_COREGL_SYMBOL(void, glStencilFunc, (GLenum func, GLint ref, GLuint mask))
_COREGL_SYMBOL(void, glStencilMask, (GLuint mask))
_COREGL_SYMBOL(void, glStencilOp, (GLenum fail, GLenum zfail, GLenum zpass))
_COREGL_SYMBOL(void, glTexImage2D, (GLenum target, GLint level,
- GLint internalformat, GLsizei width, GLsizei height, GLint border,
- GLenum format, GLenum type, const void *pixels))
+ GLint internalformat, GLsizei width, GLsizei height, GLint border,
+ GLenum format, GLenum type, const void *pixels))
_COREGL_SYMBOL(void, glTexParameteri, (GLenum target, GLenum pname,
- GLint param))
+ GLint param))
_COREGL_SYMBOL(void, glTexParameteriv, (GLenum target, GLenum pname,
- const GLint *params))
+ const GLint *params))
_COREGL_SYMBOL(void, glTexSubImage2D, (GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
- GLenum type, const void *pixels))
-_COREGL_SYMBOL(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height))
+ GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+ GLenum type, const void *pixels))
+_COREGL_SYMBOL(void, glViewport, (GLint x, GLint y, GLsizei width,
+ GLsizei height))
/* extensions */
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_mapbuffer", 1.1, -1)
_COREGL_EXT_SYMBOL(void, glGetBufferPointervOES, (GLenum target, GLenum pname,
- GLvoid **params))
+ GLvoid **params))
_COREGL_EXT_SYMBOL(void *, glMapBufferOES, (GLenum target, GLenum access))
_COREGL_EXT_SYMBOL(GLboolean, glUnmapBufferOES, (GLenum target))
_COREGL_EXT_SYMBOL(void, glBindVertexArrayOES, (GLuint array))
_COREGL_EXT_SYMBOL(void, glDeleteVertexArraysOES, (GLsizei n,
- GLuint const *arrays))
+ GLuint const *arrays))
_COREGL_EXT_SYMBOL(void, glGenVertexArraysOES, (GLsizei n, GLuint *arrays))
_COREGL_EXT_SYMBOL(GLboolean, glIsVertexArrayOES, (GLuint array))
-_COREGL_EXT_SYMBOL(void, glRenderbufferStorageMultisampleAPPLE, (GLenum, GLsizei, GLenum, GLsizei, GLsizei))
+_COREGL_EXT_SYMBOL(void, glRenderbufferStorageMultisampleAPPLE, (GLenum,
+ GLsizei, GLenum, GLsizei, GLsizei))
_COREGL_EXT_SYMBOL(void, glResolveMultisampleFramebufferAPPLE, (void))
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_discard_framebuffer", 1.0, -1)
_COREGL_EXT_SYMBOL(void, glDiscardFramebufferEXT, (GLenum target,
- GLsizei numAttachments, const GLenum *attachments))
-_COREGL_EXT_SYMBOL(void, glMultiDrawArraysEXT, (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount))
-_COREGL_EXT_SYMBOL(void, glMultiDrawElementsEXT, (GLenum mode, const GLsizei *count, GLenum type,
- const void *const*indices, GLsizei primcount))
+ GLsizei numAttachments, const GLenum *attachments))
+_COREGL_EXT_SYMBOL(void, glMultiDrawArraysEXT, (GLenum mode, const GLint *first,
+ const GLsizei *count, GLsizei primcount))
+_COREGL_EXT_SYMBOL(void, glMultiDrawElementsEXT, (GLenum mode,
+ const GLsizei *count, GLenum type,
+ const void *const *indices, GLsizei primcount))
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_multisampled_render_to_texture",2.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_multisampled_render_to_texture",
+ 2.0, -1)
_COREGL_EXT_SYMBOL(void, glRenderbufferStorageMultisampleEXT, (GLenum target,
- GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
+ GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_EXT_SYMBOL(void, glFramebufferTexture2DMultisampleEXT, (GLenum target,
- GLenum attachment, GLenum textarget, GLuint texture, GLint level,
- GLsizei samples))
-_COREGL_EXT_SYMBOL(void, glRenderbufferStorageMultisampleIMG, (GLenum, GLsizei, GLenum, GLsizei, GLsizei))
-_COREGL_EXT_SYMBOL(void, glFramebufferTexture2DMultisampleIMG, (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei))
+ GLenum attachment, GLenum textarget, GLuint texture, GLint level,
+ GLsizei samples))
+_COREGL_EXT_SYMBOL(void, glRenderbufferStorageMultisampleIMG, (GLenum, GLsizei,
+ GLenum, GLsizei, GLsizei))
+_COREGL_EXT_SYMBOL(void, glFramebufferTexture2DMultisampleIMG, (GLenum, GLenum,
+ GLenum, GLuint, GLint, GLsizei))
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_NV_fence", -1, -1)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glDeleteFencesNV)
_COREGL_EXT_SYMBOL_FASTPATH_BLOCK(glExtGetProgramBinarySourceQCOM)
_COREGL_END_API(COREGL_GLAPI_1_2_COMMON)
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_storage_multisample_2d_array", 1.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_storage_multisample_2d_array",
+ 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_sample_variables", 1.0, -1)
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_shader_multisample_interpolation", 1.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_shader_multisample_interpolation",
+ 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_KHR_blend_equation_advanced", 1.0, -1)
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_KHR_blend_equation_advanced_coherent", 1.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_KHR_blend_equation_advanced_coherent",
+ 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_shader_image_atomic", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_gpu_shader5", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_gpu_shader5", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_OES_texture_cube_map_array", 1.0, -1)
_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_texture_cube_map_array", 1.0, -1)
-_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_draw_elements_base_vertex", 1.0, -1)
+_COREGL_FASTPATH_SUPPORTED_EXTENSION("GL_EXT_draw_elements_base_vertex", 1.0,
+ -1)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glDrawElementsBaseVertexEXT)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glDrawElementsInstancedBaseVertexEXT)
_COREGL_EXT_SYMBOL_FASTPATH_PASS(glDrawRangeElementsBaseVertexEXT)
// Standard GL(glX) functions
_COREGL_SYMBOL(XVisualInfo *, glXChooseVisual, (Display *dpy, int screen,
- int *attribList))
+ int *attribList))
_COREGL_SYMBOL(GLXContext, glXCreateContext, (Display *dpy, XVisualInfo *vis,
- GLXContext shareList, Bool direct))
+ GLXContext shareList, Bool direct))
_COREGL_SYMBOL(void, glXDestroyContext, (Display *dpy, GLXContext ctx))
_COREGL_SYMBOL(GLXContext, glXGetCurrentContext, (void))
_COREGL_SYMBOL(GLXDrawable, glXGetCurrentDrawable, (void))
_COREGL_SYMBOL(Bool, glXMakeCurrent, (Display *dpy, GLXDrawable draw,
- GLXContext ctx))
+ GLXContext ctx))
_COREGL_SYMBOL(void, glXSwapBuffers, (Display *dpy, GLXDrawable draw))
_COREGL_SYMBOL(void, glXWaitX, (void))
_COREGL_SYMBOL(void, glXWaitGL, (void))
_COREGL_SYMBOL(Bool, glXQueryExtension, (Display *dpy, int *errorb, int *event))
_COREGL_SYMBOL(const char *, glXQueryExtensionsString, (Display *dpy,
- int screen))
+ int screen))
_COREGL_SYMBOL(GLXFBConfig *, glXChooseFBConfig, (Display *dpy, int screen,
- const int *attribList, int *nitems))
+ const int *attribList, int *nitems))
_COREGL_SYMBOL(GLXFBConfig *, glXGetFBConfigs, (Display *dpy, int screen,
- int *nelements))
+ int *nelements))
_COREGL_SYMBOL(int, glXGetFBConfigAttrib, (Display *dpy, GLXFBConfig config,
- int attribute, int *value))
+ int attribute, int *value))
_COREGL_SYMBOL(XVisualInfo *, glXGetVisualFromFBConfig, (Display *dpy,
- GLXFBConfig config))
+ GLXFBConfig config))
_COREGL_SYMBOL(void, glXDestroyWindow, (Display *dpy, GLXWindow window))
_COREGL_SYMBOL(Bool, glXMakeContextCurrent, (Display *dpy, GLXDrawable draw,
- GLXDrawable read, GLXContext ctx))
+ GLXDrawable read, GLXContext ctx))
_COREGL_SYMBOL(void, glXBindTexImage, (Display *dpy, GLXDrawable draw,
- int buffer, int *attribList))
+ int buffer, int *attribList))
_COREGL_SYMBOL(void, glXReleaseTexImage, (Display *dpy, GLXDrawable draw,
- int buffer))
+ int buffer))
_COREGL_SYMBOL(int, glXGetVideoSync, (unsigned int *count))
_COREGL_SYMBOL(int, glXWaitVideoSync, (int divisor, int remainder,
- unsigned int *count))
+ unsigned int *count))
_COREGL_SYMBOL(XID, glXCreatePixmap, (Display *dpy, void *config, Pixmap pixmap,
- const int *attribList))
+ const int *attribList))
_COREGL_SYMBOL(void, glXDestroyPixmap, (Display *dpy, XID pixmap))
_COREGL_SYMBOL(void, glXQueryDrawable, (Display *dpy, XID draw, int attribute,
- unsigned int *value))
+ unsigned int *value))
_COREGL_SYMBOL(int, glXSwapIntervalSGI, (int interval))
_COREGL_SYMBOL(void, glXSwapIntervalEXT, (Display *dpy, GLXDrawable draw,
- int interval))
+ int interval))
#ifdef _COREGL_EXT_SYMBOL_NOT_DEFINED
#undef _COREGL_EXT_SYMBOL_NOT_DEFINED
int i;
for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_START, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i,
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i,
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i,
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i,
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i,
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i, (GLint *)¶ms[i]);
+ _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i,
+ (GLint *)¶ms[i]);
}
}
while (current) {
if (current->cstate != NULL) {
COREGL_WRN("\E[40;31;1mContext attached to [dpy=%p|rctx=%p] has not been completely destroyed.(leak)\E[0m\n",
- current->cstate->rdpy, current->cstate->rctx);
+ current->cstate->rdpy, current->cstate->rctx);
_orig_fastpath_eglMakeCurrent(current->cstate->rdpy, EGL_NO_SURFACE,
- EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ EGL_NO_SURFACE, EGL_NO_CONTEXT);
_orig_fastpath_eglDestroyContext(current->cstate->rdpy, current->cstate->rctx);
fastpath_remove_context_states_from_list(current->cstate, NULL);
COREGL_OVERRIDE(fastpath_, glBindVertexBuffer);
}
- if(driver_gl_version >= COREGL_GLAPI_32) {
+ if (driver_gl_version >= COREGL_GLAPI_32) {
COREGL_OVERRIDE(fastpath_, glBlendEquationi);
COREGL_OVERRIDE(fastpath_, glBlendEquationSeparatei);
COREGL_OVERRIDE(fastpath_, glTexBuffer);
int
fastpath_add_context_state_to_list(const void *option, const int option_len,
- GLContextState *cstate, Mutex *mtx)
+ GLContextState *cstate, Mutex *mtx)
{
int ret = 0;
int tid = 0;
current = glctx_list;
while (current != NULL) {
if (current->option_len == option_len &&
- memcmp(current->option, option, option_len) == 0 &&
- current->thread_id == tid) {
+ memcmp(current->option, option, option_len) == 0 &&
+ current->thread_id == tid) {
AST(current->cstate == cstate);
goto finish;
}
GLContextState *
fastpath_get_context_state_from_list(const void *option, const int option_len,
- Mutex *mtx)
+ Mutex *mtx)
{
GLContextState *ret = NULL;
GLContext_List *current = NULL;
current = glctx_list;
while (current != NULL) {
if (current->option_len == option_len &&
- memcmp(current->option, option, option_len) == 0 &&
- current->thread_id == tid) {
+ memcmp(current->option, option, option_len) == 0 &&
+ current->thread_id == tid) {
ret = current->cstate;
goto finish;
}
hash_base->hash_size = oldsize << 1;
hash_base->hash_field = (GL_Object_Hash **)calloc(1,
- sizeof(GL_Object_Hash *) * hash_base->hash_size);
+ sizeof(GL_Object_Hash *) * hash_base->hash_size);
AST(hash_base->hash_field != NULL);
for (int i = 0; i < oldsize; i++) {
GLuint
fastpath_ostate_create_object(GL_Object_State *ostate, GL_Object_Type type,
- GLuint real_name)
+ GLuint real_name)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
GL_Object_Hash *newobj_hash = (GL_Object_Hash *)calloc(1,
- sizeof(GL_Object_Hash));
+ sizeof(GL_Object_Hash));
if (newobj_hash == NULL) {
free(newobj);
goto finish;
_add_hash(hash_base, newobj_hash);
GL_Object_Hash *newobj_hash_real = (GL_Object_Hash *)calloc(1,
- sizeof(GL_Object_Hash));
+ sizeof(GL_Object_Hash));
if (newobj_hash_real == NULL) {
free(newobj);
free(newobj_hash);
GLuint
fastpath_ostate_remove_object(GL_Object_State *ostate, GL_Object_Type type,
- GLuint glue_name)
+ GLuint glue_name)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
GLuint
fastpath_ostate_get_object(GL_Object_State *ostate, GL_Object_Type type,
- GLuint glue_name)
+ GLuint glue_name)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
GLint
fastpath_ostate_set_object_tag(GL_Object_State *ostate, GL_Object_Type type,
- GLuint glue_name, GLvoid *tag)
+ GLuint glue_name, GLvoid *tag)
{
GLint ret = _COREGL_INT_INIT_VALUE;
GLvoid *
fastpath_ostate_get_object_tag(GL_Object_State *ostate, GL_Object_Type type,
- GLuint glue_name)
+ GLuint glue_name)
{
GLvoid *ret = NULL;
GLuint
fastpath_ostate_find_object(GL_Object_State *ostate, GL_Object_Type type,
- GLuint real_name)
+ GLuint real_name)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
GLint
fastpath_ostate_use_object(GL_Object_State *ostate, GL_Object_Type type,
- GLuint glue_name)
+ GLuint glue_name)
{
GLint ret = _COREGL_INT_INIT_VALUE;
TRACE("\n");
TRACE("\E[0;40;34m========================================================================================================================\E[0m\n");
TRACE("\E[40;32;1m State info \E[1;37;1m: <PID = %d> GlueCTX = %p\E[0m\n",
- getpid(), ctx);
+ getpid(), ctx);
TRACE("\E[0;40;34m========================================================================================================================\E[0m\n");
#define PRINTF_CHAR_GLenum "0x%8X"
if (initial_ctx->gl_vertex_attribs_num[0] > MAX_VERTEX_ATTRIBS) {
COREGL_WRN("\E[40;31;1mNumber of vertex attrib is too big! (%d-%d)\E[0m\n",
- MAX_VERTEX_ATTRIBS, initial_ctx->gl_vertex_attribs_num[0]);
+ MAX_VERTEX_ATTRIBS, initial_ctx->gl_vertex_attribs_num[0]);
}
if (initial_ctx->gl_tex_units_num[0] > MAX_TEXTURE_UNITS) {
COREGL_WRN("\E[40;31;1mNumber of texture unit is too big! (%d-%d)\E[0m\n",
- MAX_TEXTURE_UNITS, initial_ctx->gl_tex_units_num[0]);
+ MAX_TEXTURE_UNITS, initial_ctx->gl_tex_units_num[0]);
}
if (initial_ctx->gl_transform_feedback_buffer_binding_num[0] >
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS) {
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS) {
COREGL_WRN("\E[40;31;1mNumber of transform feedback separate attrib is too big! (%d-%d)\E[0m\n",
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- initial_ctx->gl_transform_feedback_buffer_binding_num[0]);
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ initial_ctx->gl_transform_feedback_buffer_binding_num[0]);
}
if (initial_ctx->gl_uniform_buffer_binding_num[0] >
- MAX_UNIFORM_BUFFER_BINDINGS) {
+ MAX_UNIFORM_BUFFER_BINDINGS) {
COREGL_WRN("\E[40;31;1mNumber of uniform buffer binding is too big! (%d-%d)\E[0m\n",
- MAX_UNIFORM_BUFFER_BINDINGS, initial_ctx->gl_uniform_buffer_binding_num[0]);
+ MAX_UNIFORM_BUFFER_BINDINGS, initial_ctx->gl_uniform_buffer_binding_num[0]);
}
if (initial_ctx->gl_shader_storage_buffer_binding_num[0] >
- MAX_SHADER_STORAGE_BUFFER_BINDINGS) {
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS) {
COREGL_WRN("\E[40;31;1mNumber of shader storage buffer binding is too big! (%d-%d)\E[0m\n",
- MAX_SHADER_STORAGE_BUFFER_BINDINGS, initial_ctx->gl_shader_storage_buffer_binding_num[0]);
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ initial_ctx->gl_shader_storage_buffer_binding_num[0]);
}
if (initial_ctx->gl_atomic_counter_buffer_binding_num[0] >
- MAX_ATOMIC_COUNTER_BUFFER_BINDING) {
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING) {
COREGL_WRN("\E[40;31;1mNumber of uniform buffer binding is too big! (%d-%d)\E[0m\n",
- MAX_ATOMIC_COUNTER_BUFFER_BINDING, initial_ctx->gl_atomic_counter_buffer_binding_num[0]);
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ initial_ctx->gl_atomic_counter_buffer_binding_num[0]);
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
extern void *tracepath_api_trace_begin(const char *name, void *hint,
- int trace_total_time);
+ int trace_total_time);
extern void *tracepath_api_trace_end(const char *name, void *hint,
- int trace_total_time);
+ int trace_total_time);
#endif
#define CHECK_GL_ERROR(func) \
#ifdef COREGL_USE_MODULE_TRACEPATH
static void *trace_hint_glfinish = NULL;
trace_hint_glfinish = tracepath_api_trace_begin("eglMakeCurrent(FP glFinish)",
- trace_hint_glfinish, 0);
+ trace_hint_glfinish, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
{
static void *trace_hint_vertex_attrib = NULL;
trace_hint_vertex_attrib =
tracepath_api_trace_begin("eglMakeCurrent(FP vertex attrib)",
- trace_hint_vertex_attrib, 0);
+ trace_hint_vertex_attrib, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
flag = oldctx->_vattrib_flag | newctx->_vattrib_flag;
for (i = 0; i < oldctx->gl_vertex_attribs_num[0]; i++) {
if (newctx->gl_vertex_array_buf_id[i] != oldctx->gl_vertex_array_buf_id[i]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER,
- newctx->gl_vertex_array_buf_id[i]))
+ newctx->gl_vertex_array_buf_id[i]))
} else {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, 0))
}
if STATE_COMPARE(gl_vertex_array_divisor[i]) {
CHECK_GL_ERROR(_orig_fastpath_glVertexAttribDivisor(i,
- newctx->gl_vertex_array_divisor[i]))
+ newctx->gl_vertex_array_divisor[i]))
}
if (newctx->gl_vertex_array_size[i] != 0) {
CHECK_GL_ERROR(_orig_fastpath_glVertexAttribPointer(i,
- newctx->gl_vertex_array_size[i],
- newctx->gl_vertex_array_type[i],
- newctx->gl_vertex_array_normalized[i],
- newctx->gl_vertex_array_stride[i],
- newctx->gl_vertex_array_pointer[i]))
+ newctx->gl_vertex_array_size[i],
+ newctx->gl_vertex_array_type[i],
+ newctx->gl_vertex_array_normalized[i],
+ newctx->gl_vertex_array_stride[i],
+ newctx->gl_vertex_array_pointer[i]))
} else {
if (newctx->gl_vertex_array_integer[0] == GL_TRUE) {
if (newctx->gl_vertex_array_type[0] == GL_UNSIGNED_INT) {
CHECK_GL_ERROR(_orig_fastpath_glVertexAttribI4uiv(i,
- &newctx->gl_vertex_attrib_value_unsigned_integer[4 * i]))
+ &newctx->gl_vertex_attrib_value_unsigned_integer[4 * i]))
} else {
CHECK_GL_ERROR(_orig_fastpath_glVertexAttribI4iv(i,
- &newctx->gl_vertex_attrib_value_integer[4 * i]))
+ &newctx->gl_vertex_attrib_value_integer[4 * i]))
}
} else {
CHECK_GL_ERROR(_orig_fastpath_glVertexAttrib4fv(i,
- &newctx->gl_vertex_attrib_value[4 * i]))
+ &newctx->gl_vertex_attrib_value[4 * i]))
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP vertex attrib)",
- trace_hint_vertex_attrib, 0);
+ trace_hint_vertex_attrib, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
static void *trace_hint_bindbuffers = NULL;
trace_hint_bindbuffers =
tracepath_api_trace_begin("eglMakeCurrent(FP bind buffers)",
- trace_hint_bindbuffers, 0);
+ trace_hint_bindbuffers, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
//------------------//
if (flag) {
if STATE_COMPARE(gl_array_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER,
- newctx->gl_array_buffer_binding[0]))
+ newctx->gl_array_buffer_binding[0]))
}
if STATE_COMPARE(gl_element_array_buffer_binding[0]) {
if STATE_COMPARE(gl_vertex_array_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindVertexArray(
- newctx->gl_vertex_array_binding[0]))
+ newctx->gl_vertex_array_binding[0]))
}
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
- newctx->gl_element_array_buffer_binding[0]))
+ newctx->gl_element_array_buffer_binding[0]))
}
if (newctx->gl_framebuffer_binding_read_used == 1) {
if STATE_COMPARE(gl_framebuffer_binding_read[0]) {
if (driver_gl_version >= 2)
CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_READ_FRAMEBUFFER,
- newctx->gl_framebuffer_binding_read[0]))
+ newctx->gl_framebuffer_binding_read[0]))
else
CHECK_GL_ERROR(_orig_fastpath_glBindFramebufferOES(GL_READ_FRAMEBUFFER,
- newctx->gl_framebuffer_binding_read[0]))
+ newctx->gl_framebuffer_binding_read[0]))
}
if STATE_COMPARE(gl_framebuffer_binding_draw[0]) {
if (driver_gl_version >= 2)
CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_DRAW_FRAMEBUFFER,
- newctx->gl_framebuffer_binding_draw[0]))
+ newctx->gl_framebuffer_binding_draw[0]))
else
CHECK_GL_ERROR(_orig_fastpath_glBindFramebufferOES(GL_DRAW_FRAMEBUFFER,
- newctx->gl_framebuffer_binding_draw[0]))
+ newctx->gl_framebuffer_binding_draw[0]))
}
} else {
if STATE_COMPARE(gl_framebuffer_binding[0]) {
if (driver_gl_version >= 2)
CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_FRAMEBUFFER,
- newctx->gl_framebuffer_binding[0]))
+ newctx->gl_framebuffer_binding[0]))
else
CHECK_GL_ERROR(_orig_fastpath_glBindFramebufferOES(GL_FRAMEBUFFER,
- newctx->gl_framebuffer_binding[0]))
+ newctx->gl_framebuffer_binding[0]))
}
}
if STATE_COMPARE(gl_renderbuffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindRenderbuffer(GL_RENDERBUFFER,
- newctx->gl_renderbuffer_binding[0]))
+ newctx->gl_renderbuffer_binding[0]))
}
}
if (flag) {
if STATE_COMPARE(gl_copy_read_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_COPY_READ_BUFFER,
- newctx->gl_copy_read_buffer_binding[0]))
+ newctx->gl_copy_read_buffer_binding[0]))
}
if STATE_COMPARE(gl_copy_write_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_COPY_WRITE_BUFFER,
- newctx->gl_copy_write_buffer_binding[0]))
+ newctx->gl_copy_write_buffer_binding[0]))
}
if STATE_COMPARE(gl_pixel_pack_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_PIXEL_PACK_BUFFER,
- newctx->gl_pixel_pack_buffer_binding[0]))
+ newctx->gl_pixel_pack_buffer_binding[0]))
}
if STATE_COMPARE(gl_pixel_unpack_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_PIXEL_UNPACK_BUFFER,
- newctx->gl_pixel_unpack_buffer_binding[0]))
+ newctx->gl_pixel_unpack_buffer_binding[0]))
}
if STATE_COMPARE(gl_transform_feedback_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER,
- newctx->gl_transform_feedback_buffer_binding[0]))
+ newctx->gl_transform_feedback_buffer_binding[0]))
}
if STATE_COMPARE(gl_uniform_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_UNIFORM_BUFFER,
- newctx->gl_uniform_buffer_binding[0]))
+ newctx->gl_uniform_buffer_binding[0]))
}
/* handle states set in fastpath_glBindBufferBase() */
- for(i = 0; i < newctx->gl_transform_feedback_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_transform_feedback_buffer_binding_num[0]; i++) {
if STATE_COMPARE(gl_transform_feedback_buffer_binding_array[i]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i,
- newctx->gl_transform_feedback_buffer_binding_array[i]))
+ newctx->gl_transform_feedback_buffer_binding_array[i]))
}
}
- for(i = 0; i < newctx->gl_uniform_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_uniform_buffer_binding_num[0]; i++) {
if STATE_COMPARE(gl_uniform_buffer_binding_array[i]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferBase(GL_UNIFORM_BUFFER, i,
- newctx->gl_uniform_buffer_binding_array[i]))
+ newctx->gl_uniform_buffer_binding_array[i]))
}
}
}
if (flag) {
if STATE_COMPARE(gl_shader_storage_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_SHADER_STORAGE_BUFFER,
- newctx->gl_shader_storage_buffer_binding[0]))
+ newctx->gl_shader_storage_buffer_binding[0]))
}
if STATE_COMPARE(gl_atomic_counter_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ATOMIC_COUNTER_BUFFER,
- newctx->gl_atomic_counter_buffer_binding[0]))
+ newctx->gl_atomic_counter_buffer_binding[0]))
}
if STATE_COMPARE(gl_draw_indirect_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_DRAW_INDIRECT_BUFFER,
- newctx->gl_draw_indirect_buffer_binding[0]))
+ newctx->gl_draw_indirect_buffer_binding[0]))
}
if STATE_COMPARE(gl_dispatch_indirect_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER,
- newctx->gl_dispatch_indirect_buffer_binding[0]))
+ newctx->gl_dispatch_indirect_buffer_binding[0]))
}
if STATE_COMPARE(gl_texture_buffer_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_TEXTURE_BUFFER,
- newctx->gl_texture_buffer_binding[0]))
+ newctx->gl_texture_buffer_binding[0]))
}
/* handle states set in fastpath_glBindBufferBase() */
- for(i = 0; i < newctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_shader_storage_buffer_binding_num[0]; i++) {
if STATE_COMPARE(gl_shader_storage_buffer_binding_array[i]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferBase(GL_SHADER_STORAGE_BUFFER, i,
- newctx->gl_shader_storage_buffer_binding_array[i]))
+ newctx->gl_shader_storage_buffer_binding_array[i]))
}
}
- for(i = 0; i < newctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
if STATE_COMPARE(gl_atomic_counter_buffer_binding_array[i]) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, i,
- newctx->gl_atomic_counter_buffer_binding_array[i]))
+ newctx->gl_atomic_counter_buffer_binding_array[i]))
}
}
}
flag = oldctx->_bind_flag4 | newctx->_bind_flag4;
- if(flag) {
+ if (flag) {
/* handle states set in fastpath_BindBufferRrange() */
- for(i = 0; i < newctx->gl_transform_feedback_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_transform_feedback_buffer_binding_num[0]; i++) {
if (STATE_COMPARE(gl_transform_feedback_buffer_range_binding_array[i]) ||
- STATE_COMPARE(gl_transform_feedback_buffer_range_binding_array_offset[i]) ||
- STATE_COMPARE(gl_transform_feedback_buffer_range_binding_array_size[i])) {
+ STATE_COMPARE(gl_transform_feedback_buffer_range_binding_array_offset[i]) ||
+ STATE_COMPARE(gl_transform_feedback_buffer_range_binding_array_size[i])) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i,
- newctx->gl_transform_feedback_buffer_range_binding_array[i],
- newctx->gl_transform_feedback_buffer_range_binding_array_offset[i],
- newctx->gl_transform_feedback_buffer_range_binding_array_size[i]))
+ newctx->gl_transform_feedback_buffer_range_binding_array[i],
+ newctx->gl_transform_feedback_buffer_range_binding_array_offset[i],
+ newctx->gl_transform_feedback_buffer_range_binding_array_size[i]))
}
}
- for(i = 0; i < newctx->gl_uniform_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_uniform_buffer_binding_num[0]; i++) {
if (STATE_COMPARE(gl_uniform_buffer_range_binding_array[i]) ||
- STATE_COMPARE(gl_uniform_buffer_range_binding_array_offset[i]) ||
- STATE_COMPARE(gl_uniform_buffer_range_binding_array_size[i])) {
+ STATE_COMPARE(gl_uniform_buffer_range_binding_array_offset[i]) ||
+ STATE_COMPARE(gl_uniform_buffer_range_binding_array_size[i])) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferRange(GL_UNIFORM_BUFFER, i,
- newctx->gl_uniform_buffer_range_binding_array[i],
- newctx->gl_uniform_buffer_range_binding_array_offset[i],
- newctx->gl_uniform_buffer_range_binding_array_size[i]))
+ newctx->gl_uniform_buffer_range_binding_array[i],
+ newctx->gl_uniform_buffer_range_binding_array_offset[i],
+ newctx->gl_uniform_buffer_range_binding_array_size[i]))
}
}
- for(i = 0; i < newctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_shader_storage_buffer_binding_num[0]; i++) {
if (STATE_COMPARE(gl_shader_storage_buffer_range_binding_array[i]) ||
- STATE_COMPARE(gl_shader_storage_buffer_range_binding_array_offset[i]) ||
- STATE_COMPARE(gl_shader_storage_buffer_range_binding_array_size[i])) {
+ STATE_COMPARE(gl_shader_storage_buffer_range_binding_array_offset[i]) ||
+ STATE_COMPARE(gl_shader_storage_buffer_range_binding_array_size[i])) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferRange(GL_SHADER_STORAGE_BUFFER, i,
- newctx->gl_shader_storage_buffer_range_binding_array[i],
- newctx->gl_shader_storage_buffer_range_binding_array_offset[i],
- newctx->gl_shader_storage_buffer_range_binding_array_size[i]))
+ newctx->gl_shader_storage_buffer_range_binding_array[i],
+ newctx->gl_shader_storage_buffer_range_binding_array_offset[i],
+ newctx->gl_shader_storage_buffer_range_binding_array_size[i]))
}
}
- for(i = 0; i < newctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+ for (i = 0; i < newctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
if (STATE_COMPARE(gl_atomic_counter_buffer_range_binding_array[i]) ||
- STATE_COMPARE(gl_atomic_counter_buffer_range_binding_array_offset[i]) ||
- STATE_COMPARE(gl_atomic_counter_buffer_range_binding_array_size[i])) {
+ STATE_COMPARE(gl_atomic_counter_buffer_range_binding_array_offset[i]) ||
+ STATE_COMPARE(gl_atomic_counter_buffer_range_binding_array_size[i])) {
CHECK_GL_ERROR(_orig_fastpath_glBindBufferRange(GL_ATOMIC_COUNTER_BUFFER, i,
- newctx->gl_atomic_counter_buffer_range_binding_array[i],
- newctx->gl_atomic_counter_buffer_range_binding_array_offset[i],
- newctx->gl_atomic_counter_buffer_range_binding_array_size[i]))
+ newctx->gl_atomic_counter_buffer_range_binding_array[i],
+ newctx->gl_atomic_counter_buffer_range_binding_array_offset[i],
+ newctx->gl_atomic_counter_buffer_range_binding_array_size[i]))
}
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP bind buffers)",
- trace_hint_bindbuffers, 0);
+ trace_hint_bindbuffers, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
static void *trace_hint_enable_states = NULL;
trace_hint_enable_states =
tracepath_api_trace_begin("eglMakeCurrent(FP enable states)",
- trace_hint_enable_states, 0);
+ trace_hint_enable_states, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
flag = oldctx->_enable_flag1 | newctx->_enable_flag1;
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND))
- }
+ }
if STATE_COMPARE(gl_cull_face[0]) {
if (newctx->gl_cull_face[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_CULL_FACE))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_CULL_FACE))
- }
+ }
if STATE_COMPARE(gl_depth_test[0]) {
if (newctx->gl_depth_test[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DEPTH_TEST))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DEPTH_TEST))
- }
+ }
if STATE_COMPARE(gl_dither[0]) {
if (newctx->gl_dither[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DITHER))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DITHER))
- }
+ }
}
// _enable_flag2
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_POLYGON_OFFSET_FILL))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_POLYGON_OFFSET_FILL))
- }
+ }
if STATE_COMPARE(gl_sample_alpha_to_coverage[0]) {
if (newctx->gl_sample_alpha_to_coverage[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE))
- }
+ }
if STATE_COMPARE(gl_sample_coverage[0]) {
if (newctx->gl_sample_coverage[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_COVERAGE))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_COVERAGE))
- }
+ }
if STATE_COMPARE(gl_scissor_test[0]) {
if (newctx->gl_scissor_test[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SCISSOR_TEST))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SCISSOR_TEST))
- }
+ }
if STATE_COMPARE(gl_stencil_test[0]) {
if (newctx->gl_stencil_test[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_STENCIL_TEST))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_STENCIL_TEST))
- }
+ }
if STATE_COMPARE(gl_sample_shading_oes[0]) {
if (newctx->gl_sample_shading_oes[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_SHADING_OES))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_SHADING_OES))
- }
+ }
if STATE_COMPARE(gl_sample_mask[0]) {
if (newctx->gl_sample_mask[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_MASK))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_MASK))
- }
+ }
}
// _enable_flag3
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
- }
+ }
if STATE_COMPARE(gl_rasterizer_discard[0]) {
if (newctx->gl_rasterizer_discard[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_RASTERIZER_DISCARD))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_RASTERIZER_DISCARD))
- }
+ }
if STATE_COMPARE(gl_blend_advanced_coherent_khr[0]) {
if (newctx->gl_blend_advanced_coherent_khr[0]) {
CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND_ADVANCED_COHERENT_KHR))
} else
CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND_ADVANCED_COHERENT_KHR))
- }
+ }
}
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP enable states)",
- trace_hint_enable_states, 0);
+ trace_hint_enable_states, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
//------------------//
static void *trace_hint_clear_viewport = NULL;
trace_hint_clear_viewport =
tracepath_api_trace_begin("eglMakeCurrent(FP clear/viewport)",
- trace_hint_clear_viewport, 0);
+ trace_hint_clear_viewport, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
flag = oldctx->_clear_flag1 | newctx->_clear_flag1;
// Viewport.
if STATES_COMPARE(gl_viewport, 4 * sizeof(GLint)) {
CHECK_GL_ERROR(_orig_fastpath_glViewport(newctx->gl_viewport[0],
- newctx->gl_viewport[1],
- newctx->gl_viewport[2],
- newctx->gl_viewport[3]))
+ newctx->gl_viewport[1],
+ newctx->gl_viewport[2],
+ newctx->gl_viewport[3]))
}
if STATE_COMPARE(gl_current_program[0]) {
}
if STATES_COMPARE(gl_color_clear_value, 4 * sizeof(GLclampf)) {
CHECK_GL_ERROR(_orig_fastpath_glClearColor(newctx->gl_color_clear_value[0],
- newctx->gl_color_clear_value[1],
- newctx->gl_color_clear_value[2],
- newctx->gl_color_clear_value[3]))
+ newctx->gl_color_clear_value[1],
+ newctx->gl_color_clear_value[2],
+ newctx->gl_color_clear_value[3]))
}
}
if (flag) {
if STATES_COMPARE(gl_color_writemask, 4 * sizeof(GLboolean)) {
CHECK_GL_ERROR(_orig_fastpath_glColorMask(newctx->gl_color_writemask[0],
- newctx->gl_color_writemask[1],
- newctx->gl_color_writemask[2],
- newctx->gl_color_writemask[3]))
+ newctx->gl_color_writemask[1],
+ newctx->gl_color_writemask[2],
+ newctx->gl_color_writemask[3]))
}
if STATES_COMPARE(gl_depth_range, 2 * sizeof(GLclampf)) {
CHECK_GL_ERROR(_orig_fastpath_glDepthRangef(newctx->gl_depth_range[0],
- newctx->gl_depth_range[1]))
+ newctx->gl_depth_range[1]))
}
if STATE_COMPARE(gl_depth_clear_value[0]) {
CHECK_GL_ERROR(_orig_fastpath_glClearDepthf(newctx->gl_depth_clear_value[0]))
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP clear/viewport)",
- trace_hint_clear_viewport, 0);
+ trace_hint_clear_viewport, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
//------------------//
static void *trace_hint_bind_textures = NULL;
trace_hint_bind_textures =
tracepath_api_trace_begin("eglMakeCurrent(FP bind textures)",
- trace_hint_bind_textures, 0);
+ trace_hint_bind_textures, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
flag = oldctx->_tex_flag1 | newctx->_tex_flag1;
if STATE_COMPARE(gl_tex_2d_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D,
- newctx->gl_tex_2d_state[i]))
+ newctx->gl_tex_2d_state[i]))
}
if STATE_COMPARE(gl_tex_3d_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_3D,
- newctx->gl_tex_3d_state[i]))
+ newctx->gl_tex_3d_state[i]))
}
if STATE_COMPARE(gl_tex_2d_array_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_ARRAY,
- newctx->gl_tex_2d_array_state[i]))
+ newctx->gl_tex_2d_array_state[i]))
}
if STATE_COMPARE(gl_tex_cube_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_CUBE_MAP,
- newctx->gl_tex_cube_state[i]))
+ newctx->gl_tex_cube_state[i]))
}
if STATE_COMPARE(gl_tex_external_oes_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_EXTERNAL_OES,
- newctx->gl_tex_external_oes_state[i]))
+ newctx->gl_tex_external_oes_state[i]))
}
}
if STATE_COMPARE(gl_generate_mipmap_hint[0]) {
CHECK_GL_ERROR(_orig_fastpath_glHint(GL_GENERATE_MIPMAP_HINT,
- newctx->gl_generate_mipmap_hint[0]))
+ newctx->gl_generate_mipmap_hint[0]))
}
}
if STATE_COMPARE(gl_tex_buffer_ext_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_BUFFER_EXT,
- newctx->gl_tex_buffer_ext_state[i]))
+ newctx->gl_tex_buffer_ext_state[i]))
}
if STATE_COMPARE(gl_tex_2d_multisample_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE,
- newctx->gl_tex_2d_multisample_state[i]))
+ newctx->gl_tex_2d_multisample_state[i]))
}
if STATE_COMPARE(gl_tex_cube_map_array_ext_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY_EXT,
- newctx->gl_tex_cube_map_array_ext_state[i]))
+ newctx->gl_tex_cube_map_array_ext_state[i]))
}
if STATE_COMPARE(gl_tex_2d_multisample_array_oes_state[i]) {
CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES,
- newctx->gl_tex_2d_multisample_array_oes_state[i]))
+ newctx->gl_tex_2d_multisample_array_oes_state[i]))
}
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP bind textures)",
- trace_hint_bind_textures, 0);
+ trace_hint_bind_textures, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
//------------------//
#ifdef COREGL_USE_MODULE_TRACEPATH
static void *trace_hint_etc = NULL;
trace_hint_etc = tracepath_api_trace_begin("eglMakeCurrent(FP etc.)",
- trace_hint_etc, 0);
+ trace_hint_etc, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
flag = oldctx->_blend_flag | newctx->_blend_flag;
if (flag) {
if STATES_COMPARE(gl_blend_color, 4 * sizeof(GLclampf)) {
CHECK_GL_ERROR(_orig_fastpath_glBlendColor(newctx->gl_blend_color[0],
- newctx->gl_blend_color[1],
- newctx->gl_blend_color[2],
- newctx->gl_blend_color[3]))
+ newctx->gl_blend_color[1],
+ newctx->gl_blend_color[2],
+ newctx->gl_blend_color[3]))
}
if ((oldctx->gl_blend_src_rgb[0] != newctx->gl_blend_src_rgb[0]) ||
- (oldctx->gl_blend_dst_rgb[0] != newctx->gl_blend_dst_rgb[0]) ||
- (oldctx->gl_blend_src_alpha[0] != newctx->gl_blend_src_alpha[0]) ||
- (oldctx->gl_blend_dst_alpha[0] != newctx->gl_blend_dst_alpha[0])) {
+ (oldctx->gl_blend_dst_rgb[0] != newctx->gl_blend_dst_rgb[0]) ||
+ (oldctx->gl_blend_src_alpha[0] != newctx->gl_blend_src_alpha[0]) ||
+ (oldctx->gl_blend_dst_alpha[0] != newctx->gl_blend_dst_alpha[0])) {
CHECK_GL_ERROR(_orig_fastpath_glBlendFuncSeparate(newctx->gl_blend_src_rgb[0],
- newctx->gl_blend_dst_rgb[0],
- newctx->gl_blend_src_alpha[0],
- newctx->gl_blend_dst_alpha[0]))
+ newctx->gl_blend_dst_rgb[0],
+ newctx->gl_blend_src_alpha[0],
+ newctx->gl_blend_dst_alpha[0]))
}
if ((oldctx->gl_blend_equation_rgb[0] != newctx->gl_blend_equation_rgb[0]) ||
- (oldctx->gl_blend_equation_alpha[0] != newctx->gl_blend_equation_alpha[0])) {
+ (oldctx->gl_blend_equation_alpha[0] != newctx->gl_blend_equation_alpha[0])) {
CHECK_GL_ERROR(_orig_fastpath_glBlendEquationSeparate(
- newctx->gl_blend_equation_rgb[0], newctx->gl_blend_equation_alpha[0]))
+ newctx->gl_blend_equation_rgb[0], newctx->gl_blend_equation_alpha[0]))
}
}
flag = oldctx->_stencil_flag1 | newctx->_stencil_flag1;
if (flag) {
if ((oldctx->gl_stencil_func[0] != newctx->gl_stencil_func[0]) ||
- (oldctx->gl_stencil_ref[0] != newctx->gl_stencil_ref[0]) ||
- (oldctx->gl_stencil_value_mask[0] != newctx->gl_stencil_value_mask[0])) {
+ (oldctx->gl_stencil_ref[0] != newctx->gl_stencil_ref[0]) ||
+ (oldctx->gl_stencil_value_mask[0] != newctx->gl_stencil_value_mask[0])) {
CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_FRONT,
- newctx->gl_stencil_func[0],
- newctx->gl_stencil_ref[0],
- newctx->gl_stencil_value_mask[0]))
+ newctx->gl_stencil_func[0],
+ newctx->gl_stencil_ref[0],
+ newctx->gl_stencil_value_mask[0]))
}
if ((oldctx->gl_stencil_fail[0] != newctx->gl_stencil_fail[0]) ||
- (oldctx->gl_stencil_pass_depth_fail[0] != newctx->gl_stencil_pass_depth_fail[0])
- ||
- (oldctx->gl_stencil_pass_depth_pass[0] !=
- newctx->gl_stencil_pass_depth_pass[0])) {
+ (oldctx->gl_stencil_pass_depth_fail[0] != newctx->gl_stencil_pass_depth_fail[0])
+ ||
+ (oldctx->gl_stencil_pass_depth_pass[0] !=
+ newctx->gl_stencil_pass_depth_pass[0])) {
CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_FRONT,
- newctx->gl_stencil_fail[0],
- newctx->gl_stencil_pass_depth_fail[0],
- newctx->gl_stencil_pass_depth_pass[0]))
+ newctx->gl_stencil_fail[0],
+ newctx->gl_stencil_pass_depth_fail[0],
+ newctx->gl_stencil_pass_depth_pass[0]))
}
if STATE_COMPARE(gl_stencil_writemask[0]) {
CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_FRONT,
- newctx->gl_stencil_writemask[0]))
+ newctx->gl_stencil_writemask[0]))
}
}
flag = oldctx->_stencil_flag2 | newctx->_stencil_flag2;
if (flag) {
if ((oldctx->gl_stencil_back_func[0] != newctx->gl_stencil_back_func[0]) ||
- (oldctx->gl_stencil_back_ref[0] != newctx->gl_stencil_back_ref[0]) ||
- (oldctx->gl_stencil_back_value_mask[0] !=
- newctx->gl_stencil_back_value_mask[0])) {
+ (oldctx->gl_stencil_back_ref[0] != newctx->gl_stencil_back_ref[0]) ||
+ (oldctx->gl_stencil_back_value_mask[0] !=
+ newctx->gl_stencil_back_value_mask[0])) {
CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_BACK,
- newctx->gl_stencil_back_func[0],
- newctx->gl_stencil_back_ref[0],
- newctx->gl_stencil_back_value_mask[0]))
+ newctx->gl_stencil_back_func[0],
+ newctx->gl_stencil_back_ref[0],
+ newctx->gl_stencil_back_value_mask[0]))
}
if ((oldctx->gl_stencil_back_fail[0] != newctx->gl_stencil_back_fail[0]) ||
- (oldctx->gl_stencil_back_pass_depth_fail[0] !=
- newctx->gl_stencil_back_pass_depth_fail[0]) ||
- (oldctx->gl_stencil_back_pass_depth_pass[0] !=
- newctx->gl_stencil_back_pass_depth_pass[0])) {
+ (oldctx->gl_stencil_back_pass_depth_fail[0] !=
+ newctx->gl_stencil_back_pass_depth_fail[0]) ||
+ (oldctx->gl_stencil_back_pass_depth_pass[0] !=
+ newctx->gl_stencil_back_pass_depth_pass[0])) {
CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_BACK,
- newctx->gl_stencil_back_fail[0],
- newctx->gl_stencil_back_pass_depth_fail[0],
- newctx->gl_stencil_back_pass_depth_pass[0]))
+ newctx->gl_stencil_back_fail[0],
+ newctx->gl_stencil_back_pass_depth_fail[0],
+ newctx->gl_stencil_back_pass_depth_pass[0]))
}
if STATE_COMPARE(gl_stencil_back_writemask[0]) {
CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_BACK,
- newctx->gl_stencil_back_writemask[0]))
+ newctx->gl_stencil_back_writemask[0]))
}
if STATE_COMPARE(gl_stencil_clear_value[0]) {
CHECK_GL_ERROR(_orig_fastpath_glClearStencil(newctx->gl_stencil_clear_value[0]))
if (flag) {
if STATE_COMPARE(gl_pack_row_length[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_ROW_LENGTH,
- newctx->gl_pack_row_length[0]))
+ newctx->gl_pack_row_length[0]))
}
if STATE_COMPARE(gl_pack_skip_rows[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_SKIP_ROWS,
- newctx->gl_pack_skip_rows[0]))
+ newctx->gl_pack_skip_rows[0]))
}
if STATE_COMPARE(gl_pack_skip_pixels[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_SKIP_PIXELS,
- newctx->gl_pack_skip_pixels[0]))
+ newctx->gl_pack_skip_pixels[0]))
}
if STATE_COMPARE(gl_pack_alignment[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_ALIGNMENT,
- newctx->gl_pack_alignment[0]))
+ newctx->gl_pack_alignment[0]))
}
}
if (flag) {
if STATE_COMPARE(gl_unpack_row_length[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_ROW_LENGTH,
- newctx->gl_unpack_row_length[0]))
+ newctx->gl_unpack_row_length[0]))
}
if STATE_COMPARE(gl_unpack_skip_rows[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_ROWS,
- newctx->gl_unpack_skip_rows[0]))
+ newctx->gl_unpack_skip_rows[0]))
}
if STATE_COMPARE(gl_unpack_skip_pixels[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_PIXELS,
- newctx->gl_unpack_skip_pixels[0]))
+ newctx->gl_unpack_skip_pixels[0]))
}
if STATE_COMPARE(gl_unpack_alignment[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_ALIGNMENT,
- newctx->gl_unpack_alignment[0]))
+ newctx->gl_unpack_alignment[0]))
}
if STATE_COMPARE(gl_unpack_image_height[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
- newctx->gl_unpack_image_height[0]))
+ newctx->gl_unpack_image_height[0]))
}
if STATE_COMPARE(gl_unpack_skip_images[0]) {
CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_IMAGES,
- newctx->gl_unpack_skip_images[0]))
+ newctx->gl_unpack_skip_images[0]))
}
}
CHECK_GL_ERROR(_orig_fastpath_glLineWidth(newctx->gl_line_width[0]))
}
if ((oldctx->gl_polygon_offset_factor[0] != newctx->gl_polygon_offset_factor[0])
- ||
- (oldctx->gl_polygon_offset_units[0] != newctx->gl_polygon_offset_units[0])) {
+ ||
+ (oldctx->gl_polygon_offset_units[0] != newctx->gl_polygon_offset_units[0])) {
CHECK_GL_ERROR(_orig_fastpath_glPolygonOffset(
- newctx->gl_polygon_offset_factor[0],
- newctx->gl_polygon_offset_units[0]))
+ newctx->gl_polygon_offset_factor[0],
+ newctx->gl_polygon_offset_units[0]))
}
if ((oldctx->gl_sample_coverage_value[0] !=
- newctx->gl_sample_coverage_value[0]) ||
- (oldctx->gl_sample_coverage_invert[0] !=
- newctx->gl_sample_coverage_invert[0])) {
+ newctx->gl_sample_coverage_value[0]) ||
+ (oldctx->gl_sample_coverage_invert[0] !=
+ newctx->gl_sample_coverage_invert[0])) {
CHECK_GL_ERROR(_orig_fastpath_glSampleCoverage(
- newctx->gl_sample_coverage_value[0],
- newctx->gl_sample_coverage_invert[0]))
+ newctx->gl_sample_coverage_value[0],
+ newctx->gl_sample_coverage_invert[0]))
}
if STATE_COMPARE(gl_fragment_shader_derivative_hint[0]) {
CHECK_GL_ERROR(_orig_fastpath_glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
- newctx->gl_fragment_shader_derivative_hint[0]))
+ newctx->gl_fragment_shader_derivative_hint[0]))
}
}
if (flag) {
if STATES_COMPARE(gl_scissor_box, 4 * sizeof(GLint)) {
CHECK_GL_ERROR(_orig_fastpath_glScissor(newctx->gl_scissor_box[0],
- newctx->gl_scissor_box[1],
- newctx->gl_scissor_box[2],
- newctx->gl_scissor_box[3]))
+ newctx->gl_scissor_box[1],
+ newctx->gl_scissor_box[2],
+ newctx->gl_scissor_box[3]))
}
}
int drawBuffSize = 16;
/* If the context has only default framebuffer, then size of glDrawBuffers can only be 1 */
if (fastpath_ostate_has_object_type(&newctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER) == 0) {
+ GL_OBJECT_TYPE_FRAMEBUFFER) == 0) {
drawBuffSize = 1;
}
CHECK_GL_ERROR(_orig_fastpath_glDrawBuffers(drawBuffSize,
- newctx->gl_draw_buffers))
+ newctx->gl_draw_buffers))
}
if (oldctx->gl_transform_feedback_active[0] == GL_TRUE &&
- oldctx->gl_transform_feedback_paused[0] == GL_FALSE) {
+ oldctx->gl_transform_feedback_paused[0] == GL_FALSE) {
CHECK_GL_ERROR(_orig_fastpath_glPauseTransformFeedback())
}
if STATE_COMPARE(gl_transform_feedback_binding[0]) {
CHECK_GL_ERROR(_orig_fastpath_glBindTransformFeedback(GL_TRANSFORM_FEEDBACK,
- newctx->gl_transform_feedback_binding[0]))
+ newctx->gl_transform_feedback_binding[0]))
}
if (newctx->gl_transform_feedback_active[0] == GL_TRUE &&
- newctx->gl_transform_feedback_paused[0] == GL_FALSE) {
+ newctx->gl_transform_feedback_paused[0] == GL_FALSE) {
CHECK_GL_ERROR(_orig_fastpath_glResumeTransformFeedback())
}
}
TRACE("\n");
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
TRACE("\E[40;32;1m Context info \E[1;37;1m: <PID = %d> %s\E[0m\n", getpid(),
- ment);
+ ment);
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
AST(cur_tstate_tm != NULL);
TRACE(" %c Thread [0x%12x] : Surf <D=[%12p] R=[%12p]>",
- (tstate == cur_tstate_tm) ? '*' : ' ',
- cur_tstate->thread_id,
- cur_tstate_tm->rsurf_draw,
- cur_tstate_tm->rsurf_read);
+ (tstate == cur_tstate_tm) ? '*' : ' ',
+ cur_tstate->thread_id,
+ cur_tstate_tm->rsurf_draw,
+ cur_tstate_tm->rsurf_read);
if (cur_tstate_tm->cstate != NULL) {
TRACE(" GlueCTX=[%12p] RealCTX=[%12p]\E[0m\n",
- cur_tstate_tm->cstate->data,
- cur_tstate_tm->cstate);
+ cur_tstate_tm->cstate->data,
+ cur_tstate_tm->cstate);
} else {
TRACE(" (NOT BINDED TO THREAD)\E[0m\n");
}
if (cur_tstate_tm->cstate == cur_cstate) {
TRACE(" -> RealCTX [%12p] : EGLDPY=[%12p] EGLCTX=[%12p] <[%2d] GlueCTXs>\E[0m\n",
- cur_cstate,
- cur_cstate->rdpy,
- cur_cstate->rctx,
- cur_cstate->ref_count);
+ cur_cstate,
+ cur_cstate->rdpy,
+ cur_cstate->rctx,
+ cur_cstate->ref_count);
// Binded Glue Context List
{
if (cur_gctx->cstate == cur_cstate) {
TRACE(" -%c GlueCTX [%12p] : EGLDPY=[%12p] TID=[%12d] <MC count [%10d]>",
- (cur_cstate->data == cur_gctx) ? '>' : '-',
- cur_gctx,
- cur_gctx->rdpy,
- cur_gctx->thread_id,
- cur_gctx->used_count);
+ (cur_cstate->data == cur_gctx) ? '>' : '-',
+ cur_gctx,
+ cur_gctx->rdpy,
+ cur_gctx->thread_id,
+ cur_gctx->used_count);
TRACE(" <Ref [%2d]>\E[0m\n", cur_gctx->ref_count);
}
if (isbinded == 0) {
TRACE(" RealCTX [%12p] : EGLDPY=[%12p] EGLCTX=[%12p] <[%2d] GlueCTXs>\E[0m\n",
- cur_cstate,
- cur_cstate->rdpy,
- cur_cstate->rctx,
- cur_cstate->ref_count);
+ cur_cstate,
+ cur_cstate->rdpy,
+ cur_cstate->rctx,
+ cur_cstate->ref_count);
// Binded Glue Context List
{
if (cur_gctx->cstate == cur_cstate) {
TRACE(" -%c GlueCTX [%12p] : EGLDPY=[%12p] TID=[%12d] <MC count [%10d]>",
- (cur_cstate->data == cur_gctx) ? '>' : '-',
- cur_gctx,
- cur_gctx->rdpy,
- cur_gctx->thread_id,
- cur_gctx->used_count);
+ (cur_cstate->data == cur_gctx) ? '>' : '-',
+ cur_gctx,
+ cur_gctx->rdpy,
+ cur_gctx->thread_id,
+ cur_gctx->used_count);
TRACE(" <Ref [%2d]>\E[0m\n", cur_gctx->ref_count);
}
if (cur_gctx->cstate == NULL) {
TRACE(" GlueCTX [%12p] : EGLDPY=[%12p] TID=[%12d] <MC count [%10d]>",
- cur_gctx,
- cur_gctx->rdpy,
- cur_gctx->thread_id,
- cur_gctx->used_count);
+ cur_gctx,
+ cur_gctx->rdpy,
+ cur_gctx->thread_id,
+ cur_gctx->used_count);
TRACE(" <Ref [%2d]>\E[0m\n", cur_gctx->ref_count);
}
static int
_pack_egl_context_option(EGL_packed_option *pack_data, EGLDisplay dpy,
- EGLConfig cfg, EGLint force_unique, const EGLint *attrib_list)
+ EGLConfig cfg, EGLint force_unique, const EGLint *attrib_list)
{
static int force_unique_free_id = 0;
int ret = 0;
static int
_unpack_egl_context_option(EGL_packed_option *pack_data, EGLDisplay *dpy,
- EGLConfig *cfg, EGLint *force_unique, EGLint *attrib_list,
- const int attrib_list_size)
+ EGLConfig *cfg, EGLint *force_unique, EGLint *attrib_list,
+ const int attrib_list_size)
{
int ret = 0;
attrib_list_index += 2;
}
if (pack_data->attrib_list.opengl_reset_notification_strategy !=
- EGL_DONT_CARE) {
+ EGL_DONT_CARE) {
AST(attrib_list_index + 2 < attrib_list_size);
attrib_list[attrib_list_index] =
EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR;
static int
_pack_egl_context_sharable_option(EGL_packed_sharable_option *pack_data,
- EGLContext share_context)
+ EGLContext share_context)
{
int ret = 0;
#if 0
static int
_unpack_egl_context_sharable_option(EGL_packed_sharable_option *pack_data,
- EGLContext *share_context)
+ EGLContext *share_context)
{
int ret = 0;
if (tstate != NULL) {
if (tstate->cstate == cstate) {
_orig_fastpath_eglMakeCurrent(cstate->rdpy, tstate->rsurf_draw,
- tstate->rsurf_read, EGL_NO_CONTEXT);
+ tstate->rsurf_read, EGL_NO_CONTEXT);
tstate->cstate = NULL;
}
}
static void
_remove_shared_obj_state_ref(GLGlueContext *gctx,
- GL_Shared_Object_State *sostate)
+ GL_Shared_Object_State *sostate)
{
remove_from_general_trace_list(&sostate->using_gctxs, gctx);
static int
_bind_context_state(GLGlueContext *gctx, GLContextState *cstate,
- Mutex *ctx_list_mtx)
+ Mutex *ctx_list_mtx)
{
if (gctx != NULL) {
AST(gctx->cstate == cstate);
GLContextState *
_egl_create_context(EGL_packed_option *real_ctx_option,
- GLContextState **cstate_new, EGLContext *ctx,
- EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+ GLContextState **cstate_new, EGLContext *ctx,
+ EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
GLContextState *cstate = NULL;
// Pack context option
AST(_pack_egl_context_option(real_ctx_option, dpy, config, 0,
- attrib_list) == 1);
+ attrib_list) == 1);
if (debug_nofp == 1) {
AST(_pack_egl_context_option(real_ctx_option, dpy, config, 1,
- attrib_list) == 1);
+ attrib_list) == 1);
}
// Find context state
if (real_ctx_option->force_unique == 0) {
cstate = fastpath_get_context_state_from_list(real_ctx_option,
- sizeof(EGL_packed_option), &ctx_list_access_mutex);
+ sizeof(EGL_packed_option), &ctx_list_access_mutex);
}
// Create a real context if it hasn't been created
EGLint attribs[11];
_unpack_egl_context_option(current->option, &cur_dpy, NULL, NULL, attribs, 11);
if (cur_dpy == dpy) {
- if(attribs[0] == EGL_CONTEXT_MAJOR_VERSION_KHR &&
+ if (attribs[0] == EGL_CONTEXT_MAJOR_VERSION_KHR &&
attribs[1] != real_ctx_option->attrib_list.context_major_version) {
current = current->next;
continue;
AST(mutex_unlock(&ctx_list_access_mutex) == 1);
*ctx = _orig_fastpath_eglCreateContext(dpy, config, real_share_context,
- attrib_list);
+ attrib_list);
if (*ctx == EGL_NO_CONTEXT) {
COREGL_WRN("\E[40;31;1mFailed creating a egl real context for Fastpath. (Invalid config?)\E[0m\n");
(*cstate_new)->data = NULL;
AST(fastpath_add_context_state_to_list(real_ctx_option,
- sizeof(EGL_packed_option), *cstate_new, &ctx_list_access_mutex) == 1);
+ sizeof(EGL_packed_option), *cstate_new, &ctx_list_access_mutex) == 1);
#ifdef COREGL_FASTPATH_TRACE_CONTEXT_INFO
if (unlikely(trace_ctx_flag == 1))
EGLContext
fastpath_eglCreateContext(EGLDisplay dpy, EGLConfig config,
- EGLContext share_context, const EGLint *attrib_list)
+ EGLContext share_context, const EGLint *attrib_list)
{
GLGlueContext *gctx = NULL, *newgctx = NULL;
GLGlueContext_List *gctx_list_new = NULL;
goto finish;
}
cstate = _egl_create_context(real_ctx_option, &cstate_new, &ctx, dpy, config,
- attrib_list);
- if(cstate == NULL)
+ attrib_list);
+ if (cstate == NULL)
goto finish;
// Pack shared context options
real_ctx_sharable_option = (EGL_packed_sharable_option *)calloc(1,
- sizeof(EGL_packed_sharable_option));
+ sizeof(EGL_packed_sharable_option));
if (real_ctx_sharable_option == NULL) {
COREGL_ERR("\E[40;31;1mError creating a new GLGlueContext(Memory full 2)\E[0m\n");
goto finish;
}
AST(_pack_egl_context_sharable_option(real_ctx_sharable_option,
- share_context) == 1);
+ share_context) == 1);
// Allocate a new context
newgctx = (GLGlueContext *)calloc(1, sizeof(GLGlueContext));
newgctx->ostate.shared = shared_gctx->ostate.shared;
} else {
sostate_new = (GL_Shared_Object_State *)calloc(1,
- sizeof(GL_Shared_Object_State));
+ sizeof(GL_Shared_Object_State));
if (sostate_new == NULL) {
COREGL_ERR("\E[40;31;1mError creating a new GLGlueContext(Memory full 4)\E[0m\n");
goto finish;
add_to_general_trace_list(&glue_ctx_trace_list, newgctx);
snprintf(ment, sizeof(ment), "eglCreateContext completed (GlueCTX=[%12p])",
- newgctx);
+ newgctx);
_dump_context_info(ment, 1);
}
#endif // COREGL_FASTPATH_TRACE_CONTEXT_INFO
if (unlikely(trace_ctx_flag == 1)) {
char ment[256];
snprintf(ment, sizeof(ment), "eglDestroyContext completed (GlueCTX=[%12p])",
- ctx);
+ ctx);
_dump_context_info(ment, 1);
}
#endif // COREGL_FASTPATH_TRACE_CONTEXT_INFO
EGLBoolean
fastpath_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLContext real_ctx = EGL_NO_CONTEXT;
EGLBoolean
fastpath_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
- EGLContext ctx)
+ EGLContext ctx)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean need_mc = EGL_FALSE;
}
if (_orig_fastpath_eglMakeCurrent(dpy, draw, read, ctx) != EGL_TRUE) {
COREGL_WRN("Error making context [%p] current. (invalid EGL display [%p] or EGL surface [D:%p/R:%p])\n",
- ctx, dpy, draw, read);
+ ctx, dpy, draw, read);
ret = EGL_FALSE;
goto finish;
}
// Handle cross threading of context (when used by two or more gctx)
if (gctx && gctx->thread_id != get_current_thread() &&
- gctx->cstate->ref_count > 1) {
+ gctx->cstate->ref_count > 1) {
#define ATTRIB_LIST_BUFFER_SIZE 8
GLContextState *cstate_new = NULL;
int attrib_list[ATTRIB_LIST_BUFFER_SIZE];
AST(_unpack_egl_context_option(gctx->real_ctx_option, &dpy, &config, NULL,
- attrib_list, ATTRIB_LIST_BUFFER_SIZE) == 1);
+ attrib_list, ATTRIB_LIST_BUFFER_SIZE) == 1);
AST(dpy == gctx->rdpy);
_egl_create_context(gctx->real_ctx_option, &cstate_new, &new_real_ctx, dpy,
- config, attrib_list);
+ config, attrib_list);
AST(cstate_new != NULL);
// If drawable changed, do a make current
if (tstate &&
- ((tstate->rsurf_draw != draw) || (tstate->rsurf_read != read)))
+ ((tstate->rsurf_draw != draw) || (tstate->rsurf_read != read)))
need_mc = EGL_TRUE;
AST(gctx && (gctx->cstate != NULL));
// If binded real context changed, do a make current
if (tstate && gctx && ((tstate->cstate == NULL) ||
- (tstate->cstate != gctx->cstate)))
+ (tstate->cstate != gctx->cstate)))
need_mc = EGL_TRUE;
if (tstate && gctx && gctx->cstate && (need_mc == EGL_TRUE)) {
// BB : full makecurrent
if (_orig_fastpath_eglMakeCurrent(dpy, draw, read,
- gctx->cstate->rctx) != EGL_TRUE) {
+ gctx->cstate->rctx) != EGL_TRUE) {
COREGL_WRN("\E[40;31;1mError making context current with the drawable. (Bad match?)\E[0m\n");
ret = EGL_FALSE;
goto finish;
}
- current_gl_api_version = ((EGL_packed_option *)gctx->real_ctx_option)->attrib_list.context_major_version;
- if(current_gl_api_version == COREGL_GLAPI_1)
+ current_gl_api_version = ((EGL_packed_option *)
+ gctx->real_ctx_option)->attrib_list.context_major_version;
+ if (current_gl_api_version == COREGL_GLAPI_1)
init_export(GL_FALSE, GL_TRUE);
// Update references only when the contexts are different
if (tstate->cstate != gctx->cstate) {
if (tstate->cstate != NULL && tstate->cstate->data != NULL)
_remove_context_ref((GLGlueContext *)tstate->cstate->data,
- &ctx_list_access_mutex);
+ &ctx_list_access_mutex);
tstate->cstate = gctx->cstate;
}
if (tstate &&
- (_bind_context_state(gctx, tstate->cstate, &ctx_list_access_mutex) != 1)) {
+ (_bind_context_state(gctx, tstate->cstate, &ctx_list_access_mutex) != 1)) {
ret = EGL_FALSE;
goto finish;
}
if (unlikely(trace_ctx_flag == 1)) {
char ment[256];
snprintf(ment, sizeof(ment),
- "eglMakeCurrent finished (GlueCTX=[%12p] Surf=[D:%12p R:%12p])",
- ctx, draw, read);
+ "eglMakeCurrent finished (GlueCTX=[%12p] Surf=[D:%12p R:%12p])",
+ ctx, draw, read);
_dump_context_info(ment, 0);
}
#endif // COREGL_FASTPATH_TRACE_CONTEXT_INFO
EGLImageKHR
fastpath_eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target,
- EGLClientBuffer buffer, const EGLint *attrib_list)
+ EGLClientBuffer buffer, const EGLint *attrib_list)
{
void *ret = NULL;
EGLContext real_ctx = EGL_NO_CONTEXT;
EGLClientBuffer real_obj;
GL_Object_Type type = 0;
- if((EGLint)buffer & GL_OBJECT_TYPE_TEXTURE)
+ if ((EGLint)buffer & GL_OBJECT_TYPE_TEXTURE)
type = GL_OBJECT_TYPE_TEXTURE;
- else if((EGLint)buffer & GL_OBJECT_TYPE_RENDERBUFFER)
+ else if ((EGLint)buffer & GL_OBJECT_TYPE_RENDERBUFFER)
type = GL_OBJECT_TYPE_RENDERBUFFER;
else {
COREGL_ERR("\E[40;31;1m fastpath_eglCreateImageKHR buffer type error \E[0m\n");
real_obj = NULL;
} else {
real_obj = (EGLClientBuffer)(uintptr_t)fastpath_ostate_get_object(&gctx->ostate,
- type, (GLuint)(uintptr_t)buffer);
+ type, (GLuint)(uintptr_t)buffer);
}
break;
default:
}
ret = _orig_fastpath_eglCreateImageKHR(dpy, real_ctx, target, real_obj,
- attrib_list);
+ attrib_list);
goto finish;
#undef _COREGL_EXT_SYMBOL_FASTPATH_BLOCK
COREGL_ERR("\E[40;31;1mFASTPATH can't support '%s' (will be terminated with Illegal instruction!)\E[0m\n",
- procname);
+ procname);
assert(0);
}
static inline int
_get_real_obj(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_handle,
- GLuint *real_handle)
+ GLuint *real_handle)
{
if (glue_handle == 0) {
*real_handle = 0;
static inline int
_get_glue_obj(GL_Object_State *ostate, GL_Object_Type type, GLuint real_handle,
- GLuint *glue_handle)
+ GLuint *glue_handle)
{
if (real_handle == 0) {
*glue_handle = 0;
GLuint
_create_program_object(GL_Object_State *ostate, int is_program,
- GLenum shader_type)
+ GLenum shader_type)
{
GLuint ret = 0;
GLuint real_obj = 0;
AST(poat != NULL);
real_program = fastpath_ostate_get_object(ostate, GL_OBJECT_TYPE_PROGRAM,
- program);
+ program);
AST(real_program > 0);
_orig_fastpath_glGetAttachedShaders(real_program, 10, &poat->shader_count,
- poat->shaders);
+ poat->shaders);
}
static void
static void
_detach_program_object(GL_Object_State *ostate, GLuint real_object,
- int is_program, int is_deleting)
+ int is_program, int is_deleting)
{
if (real_object != 0) {
GLuint object = _COREGL_INT_INIT_VALUE;
Program_object_attached_tag *poat = NULL;
object = fastpath_ostate_find_object(ostate, GL_OBJECT_TYPE_PROGRAM,
- real_object);
+ real_object);
AST(object != 0);
poat = (Program_object_attached_tag *)fastpath_ostate_get_object_tag(ostate,
len = strlen(res);
char *str = malloc(len + 1);
- if(!str) {
+ if (!str) {
return;
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- if(CURR_STATE_COMPARE(gl_sample_coverage_value, 0, value) ||
- CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
+ if (CURR_STATE_COMPARE(gl_sample_coverage_value, 0, value) ||
+ CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
IF_GL_SUCCESS(_orig_fastpath_glSampleCoveragex(value, invert)) {
current_ctx->_misc_flag1 |=
_MISC_FLAG1_BIT_gl_sample_coverage_value |
double GLver = _get_gl_version();
if (GLver > 3.2f) {
COREGL_WRN("\E[40;31;1mFastpath can't support %s (Fixed to %s)\E[0m\n", ret,
- string_gles32);
+ string_gles32);
ret = string_gles32;
}
if (GLver < 1.1) {
COREGL_WRN("\E[40;31;1mFastpath can't support %s (Fixed to %s)\E[0m\n", ret,
- string_gles11);
+ string_gles11);
ret = string_gles11;
}
}
IF_GL_SUCCESS(_orig_fastpath_glGenTextures(n, objid_array)) {
for (i = 0; i < n; i++) {
textures[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_TEXTURE, objid_array[i]);
+ GL_OBJECT_TYPE_TEXTURE, objid_array[i]);
}
}
if (textures[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_TEXTURE, textures[i]);
+ GL_OBJECT_TYPE_TEXTURE, textures[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_TEXTURE,
- textures[i]) == 1);
+ textures[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glFramebufferTexture2D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
GLuint real_obj;
}
_orig_fastpath_glFramebufferTexture2D(target, attachment, textarget, real_obj,
- level);
+ level);
goto finish;
void
fastpath_glFramebufferTexture3DOES(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+ GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
GLuint real_obj;
break;
case GL_RENDERBUFFER:
if (GET_GLUE_OBJ(GL_OBJECT_TYPE_RENDERBUFFER, real_obj,
- (GLuint *)params) != 1) {
+ (GLuint *)params) != 1) {
params[0] = 0;
goto finish;
}
IF_GL_SUCCESS(_orig_fastpath_glGenBuffers(n, objid_array)) {
for (i = 0; i < n; i++) {
buffers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_BUFFER, objid_array[i]);
+ GL_OBJECT_TYPE_BUFFER, objid_array[i]);
}
}
if (GET_REAL_OBJ(GL_OBJECT_TYPE_BUFFER, buffer, &real_obj) != 1)
real_obj = buffer;
-/* clear states set in fastpath_glBindBufferBase() */
+ /* clear states set in fastpath_glBindBufferBase() */
#define BIND_STATE_ARRAY_CLEAR(gl_state) \
if (buffer == 0) { \
for(index = 0; index < current_ctx->gl_state##_num[0]; index++) { \
break;
case GL_COPY_READ_BUFFER:
STATE_PROC_WITH_CHECK(gl_copy_read_buffer_binding, _bind_flag2,
- _BIND_FLAG2_BIT);
+ _BIND_FLAG2_BIT);
break;
case GL_COPY_WRITE_BUFFER:
STATE_PROC_WITH_CHECK(gl_copy_write_buffer_binding, _bind_flag2,
- _BIND_FLAG2_BIT);
+ _BIND_FLAG2_BIT);
break;
case GL_ELEMENT_ARRAY_BUFFER:
STATE_PROC(gl_element_array_buffer_binding, _bind_flag1, _BIND_FLAG1_BIT);
break;
case GL_PIXEL_PACK_BUFFER:
STATE_PROC_WITH_CHECK(gl_pixel_pack_buffer_binding, _bind_flag2,
- _BIND_FLAG2_BIT);
+ _BIND_FLAG2_BIT);
break;
case GL_PIXEL_UNPACK_BUFFER:
STATE_PROC_WITH_CHECK(gl_pixel_unpack_buffer_binding, _bind_flag2,
- _BIND_FLAG2_BIT);
+ _BIND_FLAG2_BIT);
break;
case GL_TRANSFORM_FEEDBACK_BUFFER:
STATE_PROC_WITH_CHECK(gl_transform_feedback_buffer_binding, _bind_flag2,
- _BIND_FLAG2_BIT);
+ _BIND_FLAG2_BIT);
BIND_STATE_ARRAY_CLEAR(gl_transform_feedback_buffer_binding);
break;
case GL_UNIFORM_BUFFER:
BIND_STATE_ARRAY_CLEAR(gl_uniform_buffer_binding);
break;
case GL_SHADER_STORAGE_BUFFER:
- STATE_PROC_WITH_CHECK(gl_shader_storage_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+ STATE_PROC_WITH_CHECK(gl_shader_storage_buffer_binding, _bind_flag3,
+ _BIND_FLAG3_BIT);
BIND_STATE_ARRAY_CLEAR(gl_shader_storage_buffer_binding);
break;
case GL_ATOMIC_COUNTER_BUFFER:
- STATE_PROC_WITH_CHECK(gl_atomic_counter_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+ STATE_PROC_WITH_CHECK(gl_atomic_counter_buffer_binding, _bind_flag3,
+ _BIND_FLAG3_BIT);
BIND_STATE_ARRAY_CLEAR(gl_atomic_counter_buffer_binding);
break;
case GL_DRAW_INDIRECT_BUFFER:
- STATE_PROC_WITH_CHECK(gl_draw_indirect_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+ STATE_PROC_WITH_CHECK(gl_draw_indirect_buffer_binding, _bind_flag3,
+ _BIND_FLAG3_BIT);
break;
case GL_DISPATCH_INDIRECT_BUFFER:
- STATE_PROC_WITH_CHECK(gl_dispatch_indirect_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+ STATE_PROC_WITH_CHECK(gl_dispatch_indirect_buffer_binding, _bind_flag3,
+ _BIND_FLAG3_BIT);
break;
case GL_TEXTURE_BUFFER:
STATE_PROC_WITH_CHECK(gl_texture_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
void
fastpath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
- GLintptr offset, GLsizeiptr size)
+ GLintptr offset, GLsizeiptr size)
{
GLuint real_obj;
switch (target) {
case GL_TRANSFORM_FEEDBACK_BUFFER:
- STATE_PROC(gl_transform_feedback_buffer_range_binding, _bind_flag4, _BIND_FLAG4_BIT_);
+ STATE_PROC(gl_transform_feedback_buffer_range_binding, _bind_flag4,
+ _BIND_FLAG4_BIT_);
break;
case GL_UNIFORM_BUFFER:
STATE_PROC(gl_uniform_buffer_range_binding, _bind_flag4, _BIND_FLAG4_BIT_);
break;
case GL_SHADER_STORAGE_BUFFER:
- STATE_PROC(gl_shader_storage_buffer_range_binding, _bind_flag4, _BIND_FLAG4_BIT_);
+ STATE_PROC(gl_shader_storage_buffer_range_binding, _bind_flag4,
+ _BIND_FLAG4_BIT_);
break;
case GL_ATOMIC_COUNTER_BUFFER:
- STATE_PROC(gl_atomic_counter_buffer_range_binding, _bind_flag4, _BIND_FLAG4_BIT_);
+ STATE_PROC(gl_atomic_counter_buffer_range_binding, _bind_flag4,
+ _BIND_FLAG4_BIT_);
break;
default:
_set_gl_error(GL_INVALID_ENUM);
if (buffers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_BUFFER, buffers[i]);
+ GL_OBJECT_TYPE_BUFFER, buffers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_BUFFER,
- buffers[i]) == 1);
+ buffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
CURR_STATE_CLEAR(gl_uniform_buffer_binding, 0)
}
/* clear states array set in fastpath_glBindBufferBase() */
- for(j = 0; j < cur_gctx->gl_transform_feedback_buffer_binding_num[0]; j++) {
+ for (j = 0; j < cur_gctx->gl_transform_feedback_buffer_binding_num[0]; j++) {
if (cur_gctx->gl_transform_feedback_buffer_binding_array[j] == objid_array[i]) {
cur_gctx->_bind_flag2 &=
(~_BIND_FLAG2_BIT_gl_transform_feedback_buffer_binding);
CURR_STATE_CLEAR(gl_transform_feedback_buffer_binding_array, j)
}
}
- for(j = 0; j < cur_gctx->gl_uniform_buffer_binding_num[0]; j++) {
+ for (j = 0; j < cur_gctx->gl_uniform_buffer_binding_num[0]; j++) {
if (cur_gctx->gl_uniform_buffer_binding_array[j] == objid_array[i]) {
cur_gctx->_bind_flag2 &= (~_BIND_FLAG2_BIT_gl_uniform_buffer_binding);
CURR_STATE_CLEAR(gl_uniform_buffer_binding_array, j)
}
}
- for(j = 0; j < cur_gctx->gl_shader_storage_buffer_binding_num[0]; j++) {
+ for (j = 0; j < cur_gctx->gl_shader_storage_buffer_binding_num[0]; j++) {
if (cur_gctx->gl_shader_storage_buffer_binding_array[j] == objid_array[i]) {
cur_gctx->_bind_flag3 &= (~_BIND_FLAG3_BIT_gl_shader_storage_buffer_binding);
CURR_STATE_CLEAR(gl_shader_storage_buffer_binding_array, j)
}
}
- for(j = 0; j < cur_gctx->gl_atomic_counter_buffer_binding_num[0]; j++) {
+ for (j = 0; j < cur_gctx->gl_atomic_counter_buffer_binding_num[0]; j++) {
if (cur_gctx->gl_atomic_counter_buffer_binding_array[j] == objid_array[i]) {
cur_gctx->_bind_flag3 &= (~_BIND_FLAG3_BIT_gl_atomic_counter_buffer_binding);
CURR_STATE_CLEAR(gl_atomic_counter_buffer_binding_array, j)
}
}
/* clear states array set in fastpath_glBindBufferRange() */
- for(j = 0; j < cur_gctx->gl_transform_feedback_buffer_binding_num[0]; j++) {
- if (cur_gctx->gl_transform_feedback_buffer_range_binding_array[j] == objid_array[i]) {
- cur_gctx->_bind_flag3 &= (~_BIND_FLAG4_BIT_gl_transform_feedback_buffer_range_binding);
+ for (j = 0; j < cur_gctx->gl_transform_feedback_buffer_binding_num[0]; j++) {
+ if (cur_gctx->gl_transform_feedback_buffer_range_binding_array[j] ==
+ objid_array[i]) {
+ cur_gctx->_bind_flag3 &=
+ (~_BIND_FLAG4_BIT_gl_transform_feedback_buffer_range_binding);
CURR_STATE_CLEAR(gl_transform_feedback_buffer_range_binding_array, j)
cur_gctx->gl_transform_feedback_buffer_range_binding_array_offset[j] = 0;
cur_gctx->gl_transform_feedback_buffer_range_binding_array_size[j] = 0;
}
}
- for(j = 0; j < cur_gctx->gl_uniform_buffer_binding_num[0]; j++) {
+ for (j = 0; j < cur_gctx->gl_uniform_buffer_binding_num[0]; j++) {
if (cur_gctx->gl_uniform_buffer_range_binding_array[j] == objid_array[i]) {
cur_gctx->_bind_flag3 &= (~_BIND_FLAG4_BIT_gl_uniform_buffer_range_binding);
CURR_STATE_CLEAR(gl_uniform_buffer_range_binding_array, j)
cur_gctx->gl_uniform_buffer_range_binding_array_size[j] = 0;
}
}
- for(j = 0; j < cur_gctx->gl_shader_storage_buffer_binding_num[0]; j++) {
- if (cur_gctx->gl_shader_storage_buffer_range_binding_array[j] == objid_array[i]) {
- cur_gctx->_bind_flag4 &= (~_BIND_FLAG4_BIT_gl_shader_storage_buffer_range_binding);
+ for (j = 0; j < cur_gctx->gl_shader_storage_buffer_binding_num[0]; j++) {
+ if (cur_gctx->gl_shader_storage_buffer_range_binding_array[j] ==
+ objid_array[i]) {
+ cur_gctx->_bind_flag4 &=
+ (~_BIND_FLAG4_BIT_gl_shader_storage_buffer_range_binding);
CURR_STATE_CLEAR(gl_shader_storage_buffer_range_binding_array, j)
cur_gctx->gl_shader_storage_buffer_range_binding_array_offset[j] = 0;
cur_gctx->gl_shader_storage_buffer_range_binding_array_size[j] = 0;
}
}
- for(j = 0; j < cur_gctx->gl_atomic_counter_buffer_binding_num[0]; j++) {
- if (cur_gctx->gl_atomic_counter_buffer_range_binding_array[j] == objid_array[i]) {
- cur_gctx->_bind_flag4 &= (~_BIND_FLAG4_BIT_gl_atomic_counter_buffer_range_binding);
+ for (j = 0; j < cur_gctx->gl_atomic_counter_buffer_binding_num[0]; j++) {
+ if (cur_gctx->gl_atomic_counter_buffer_range_binding_array[j] ==
+ objid_array[i]) {
+ cur_gctx->_bind_flag4 &=
+ (~_BIND_FLAG4_BIT_gl_atomic_counter_buffer_range_binding);
CURR_STATE_CLEAR(gl_atomic_counter_buffer_range_binding_array, j)
cur_gctx->gl_atomic_counter_buffer_range_binding_array_offset[j] = 0;
cur_gctx->gl_atomic_counter_buffer_range_binding_array_size[j] = 0;
IF_GL_SUCCESS(_orig_fastpath_glGenFramebuffers(n, objid_array)) {
for (i = 0; i < n; i++) {
framebuffers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
+ GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
}
}
} \
}
- switch(target) {
- case GL_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_read_used)
- STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
+ switch (target) {
+ case GL_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_read_used)
+ STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
if (current_ctx->gl_framebuffer_binding_draw_used)
STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
- if(!current_ctx->gl_framebuffer_binding_read_used && !current_ctx->gl_framebuffer_binding_draw_used)
- STATE_PROC(gl_framebuffer_binding, _bind_flag1, _BIND_FLAG1_BIT)
- break;
- case GL_READ_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_read_used)
- STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
+ if (!current_ctx->gl_framebuffer_binding_read_used &&
+ !current_ctx->gl_framebuffer_binding_draw_used)
+ STATE_PROC(gl_framebuffer_binding, _bind_flag1, _BIND_FLAG1_BIT)
+ break;
+ case GL_READ_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_read_used)
+ STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
break;
- case GL_DRAW_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_draw_used)
- STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
+ case GL_DRAW_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_draw_used)
+ STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
break;
- default:
- _set_gl_error(GL_INVALID_ENUM);
- goto finish;
+ default:
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
#undef STATE_PROC
if (framebuffers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
+ GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]) == 1);
+ GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
IF_GL_SUCCESS(_orig_fastpath_glGenRenderbuffers(n, objid_array)) {
for (i = 0; i < n; i++) {
renderbuffers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
+ GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
}
}
void
fastpath_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
GLuint real_obj;
if (renderbuffers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
+ GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]) == 1);
+ GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glShaderSource(GLuint shader, GLsizei count, const char **string,
- const GLint *length)
+ const GLint *length)
{
GLuint real_obj;
void
fastpath_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
- const void *binary, GLsizei length)
+ const void *binary, GLsizei length)
{
int i;
GLuint *objid_array = NULL;
for (i = 0; i < n; i++) {
if (shaders[i] == 0) continue;
objid_array[i] = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAM, shaders[i]);
+ GL_OBJECT_TYPE_PROGRAM, shaders[i]);
}
_orig_fastpath_glShaderBinary(n, objid_array, binaryformat, binary, length);
INIT_FASTPATH_GL_FUNC();
if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj_program) != 1 ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
IF_GL_SUCCESS(_orig_fastpath_glAttachShader(real_obj_program,
- real_obj_shader)) {
+ real_obj_shader)) {
_update_program_attach_info(¤t_ctx->ostate, program);
_attach_program_object(¤t_ctx->ostate, shader);
}
INIT_FASTPATH_GL_FUNC();
if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj_program) != 1 ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
IF_GL_SUCCESS(_orig_fastpath_glDetachShader(real_obj_program,
- real_obj_shader)) {
+ real_obj_shader)) {
_update_program_attach_info(¤t_ctx->ostate, program);
_detach_program_object(¤t_ctx->ostate, real_obj_shader, 0, 0);
}
IF_GL_SUCCESS(_orig_fastpath_glUseProgram(real_obj)) {
_attach_program_object(¤t_ctx->ostate, program);
_detach_program_object(¤t_ctx->ostate, current_ctx->gl_current_program[0],
- 1, 0);
+ 1, 0);
current_ctx->_clear_flag1 |= _CLEAR_FLAG1_BIT_gl_current_program;
CURR_STATE_UPDATE(gl_current_program, 0, real_obj)
}
- }
- else if(current_ctx->gl_transform_feedback_active[0] == GL_TRUE &&
- current_ctx->gl_transform_feedback_paused[0] == GL_FALSE) {
+ } else if (current_ctx->gl_transform_feedback_active[0] == GL_TRUE &&
+ current_ctx->gl_transform_feedback_paused[0] == GL_FALSE) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
void
fastpath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
GLuint real_obj;
}
_orig_fastpath_glGetActiveAttrib(real_obj, index, bufsize, length, size, type,
- name);
+ name);
goto finish;
void
fastpath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
GLuint real_obj;
}
_orig_fastpath_glGetActiveUniform(real_obj, index, bufsize, length, size, type,
- name);
+ name);
goto finish;
void
fastpath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count,
- GLuint *shaders)
+ GLuint *shaders)
{
int i;
GLsizei real_count = _COREGL_INT_INIT_VALUE;
}
IF_GL_SUCCESS(_orig_fastpath_glGetAttachedShaders(real_obj, maxcount,
- &real_count, shaders)) {
+ &real_count, shaders)) {
for (i = 0; i < real_count; i++) {
if (shaders[i] != 0)
shaders[i] = fastpath_ostate_find_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAM, shaders[i]);
+ GL_OBJECT_TYPE_PROGRAM, shaders[i]);
}
if (count != NULL) *count = real_count;
}
void
fastpath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
GLuint real_obj;
void
fastpath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
GLuint real_obj;
void
fastpath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *source)
+ char *source)
{
GLuint real_obj;
void
fastpath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages,
- GLuint program)
+ GLuint program)
{
GLuint real_obj;
goto finish;
}
- if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_pipeline_obj) != 1) {
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline,
+ &real_pipeline_obj) != 1) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
void
fastpath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x, GLint y,
- GLint z)
+ GLint z)
{
GLuint real_obj;
void
fastpath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x, GLint y,
- GLint z, GLint w)
+ GLint z, GLint w)
{
GLuint real_obj;
void
fastpath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y)
+ GLfloat y)
{
GLuint real_obj;
void
fastpath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z)
+ GLfloat y, GLfloat z)
{
GLuint real_obj;
void
fastpath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z, GLfloat w)
+ GLfloat y, GLfloat z, GLfloat w)
{
GLuint real_obj;
void
fastpath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_blend_color, 0, red) ||
- CURR_STATE_COMPARE(gl_blend_color, 1, green) ||
- CURR_STATE_COMPARE(gl_blend_color, 2, blue) ||
- CURR_STATE_COMPARE(gl_blend_color, 3, alpha)) {
+ CURR_STATE_COMPARE(gl_blend_color, 1, green) ||
+ CURR_STATE_COMPARE(gl_blend_color, 2, blue) ||
+ CURR_STATE_COMPARE(gl_blend_color, 3, alpha)) {
IF_GL_SUCCESS(_orig_fastpath_glBlendColor(red, green, blue, alpha)) {
current_ctx->_blend_flag |= _BLEND_FLAG_BIT_gl_blend_color;
CURR_STATE_UPDATE(gl_blend_color, 0, red)
_BLEND_FLAG_BIT_gl_blend_equation_alpha;
_orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_RGB,
- (GLint *) (current_ctx->gl_blend_equation_rgb));
+ (GLint *) (current_ctx->gl_blend_equation_rgb));
_orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_ALPHA,
- (GLint *) (current_ctx->gl_blend_equation_alpha));
+ (GLint *) (current_ctx->gl_blend_equation_alpha));
}
goto finish;
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_blend_equation_rgb, 0, modeRGB) ||
- CURR_STATE_COMPARE(gl_blend_equation_alpha, 0, modeAlpha)) {
+ CURR_STATE_COMPARE(gl_blend_equation_alpha, 0, modeAlpha)) {
IF_GL_SUCCESS(_orig_fastpath_glBlendEquationSeparate(modeRGB, modeAlpha)) {
current_ctx->_blend_flag |=
_BLEND_FLAG_BIT_gl_blend_equation_rgb |
_BLEND_FLAG_BIT_gl_blend_dst_alpha;
_orig_fastpath_glGetIntegerv(GL_BLEND_SRC_RGB,
- (GLint *) (current_ctx->gl_blend_src_rgb));
+ (GLint *) (current_ctx->gl_blend_src_rgb));
_orig_fastpath_glGetIntegerv(GL_BLEND_SRC_ALPHA,
- (GLint *) (current_ctx->gl_blend_src_alpha));
+ (GLint *) (current_ctx->gl_blend_src_alpha));
_orig_fastpath_glGetIntegerv(GL_BLEND_DST_RGB,
- (GLint *) (current_ctx->gl_blend_dst_rgb));
+ (GLint *) (current_ctx->gl_blend_dst_rgb));
_orig_fastpath_glGetIntegerv(GL_BLEND_DST_ALPHA,
- (GLint *) (current_ctx->gl_blend_dst_alpha));
+ (GLint *) (current_ctx->gl_blend_dst_alpha));
}
goto finish;
void
fastpath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
- GLenum dstAlpha)
+ GLenum dstAlpha)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_blend_src_rgb, 0, srcRGB) ||
- CURR_STATE_COMPARE(gl_blend_dst_rgb, 0, dstRGB) ||
- CURR_STATE_COMPARE(gl_blend_src_alpha, 0, srcAlpha) ||
- CURR_STATE_COMPARE(gl_blend_dst_alpha, 0, dstAlpha)) {
+ CURR_STATE_COMPARE(gl_blend_dst_rgb, 0, dstRGB) ||
+ CURR_STATE_COMPARE(gl_blend_src_alpha, 0, srcAlpha) ||
+ CURR_STATE_COMPARE(gl_blend_dst_alpha, 0, dstAlpha)) {
IF_GL_SUCCESS(_orig_fastpath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha,
- dstAlpha)) {
+ dstAlpha)) {
current_ctx->_blend_flag |=
_BLEND_FLAG_BIT_gl_blend_src_rgb |
_BLEND_FLAG_BIT_gl_blend_src_alpha |
void
fastpath_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_color_clear_value, 0, red) ||
- CURR_STATE_COMPARE(gl_color_clear_value, 1, green) ||
- CURR_STATE_COMPARE(gl_color_clear_value, 2, blue) ||
- CURR_STATE_COMPARE(gl_color_clear_value, 3, alpha)) {
+ CURR_STATE_COMPARE(gl_color_clear_value, 1, green) ||
+ CURR_STATE_COMPARE(gl_color_clear_value, 2, blue) ||
+ CURR_STATE_COMPARE(gl_color_clear_value, 3, alpha)) {
IF_GL_SUCCESS(_orig_fastpath_glClearColor(red, green, blue, alpha)) {
current_ctx->_clear_flag1 |= _CLEAR_FLAG1_BIT_gl_color_clear_value;
CURR_STATE_UPDATE(gl_color_clear_value, 0, red)
void
fastpath_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
- GLboolean alpha)
+ GLboolean alpha)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_color_writemask, 0, red) ||
- CURR_STATE_COMPARE(gl_color_writemask, 1, green) ||
- CURR_STATE_COMPARE(gl_color_writemask, 2, blue) ||
- CURR_STATE_COMPARE(gl_color_writemask, 3, alpha)) {
+ CURR_STATE_COMPARE(gl_color_writemask, 1, green) ||
+ CURR_STATE_COMPARE(gl_color_writemask, 2, blue) ||
+ CURR_STATE_COMPARE(gl_color_writemask, 3, alpha)) {
IF_GL_SUCCESS(_orig_fastpath_glColorMask(red, green, blue, alpha)) {
current_ctx->_clear_flag2 |= _CLEAR_FLAG2_BIT_gl_color_writemask;
CURR_STATE_UPDATE(gl_color_writemask, 0, red)
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_depth_range, 0, zNear) ||
- CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
+ CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
IF_GL_SUCCESS(_orig_fastpath_glDepthRangef(zNear, zFar)) {
current_ctx->_clear_flag2 |= _CLEAR_FLAG2_BIT_gl_depth_range;
CURR_STATE_UPDATE(gl_depth_range, 0, zNear)
break;
case GL_PRIMITIVE_RESTART_FIXED_INDEX:
STATE_PROC_WITH_CHECK(gl_primitive_restart_fixed_index, _enable_flag3,
- _ENABLE_FLAG3_BIT);
+ _ENABLE_FLAG3_BIT);
break;
case GL_RASTERIZER_DISCARD:
STATE_PROC_WITH_CHECK(gl_rasterizer_discard, _enable_flag3, _ENABLE_FLAG3_BIT);
break;
case GL_PRIMITIVE_RESTART_FIXED_INDEX:
STATE_PROC_WITH_CHECK(gl_primitive_restart_fixed_index, _enable_flag3,
- _ENABLE_FLAG3_BIT);
+ _ENABLE_FLAG3_BIT);
break;
case GL_RASTERIZER_DISCARD:
STATE_PROC_WITH_CHECK(gl_rasterizer_discard, _enable_flag3, _ENABLE_FLAG3_BIT);
switch (target) {
case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
STATE_PROC_WITH_CHECK(gl_fragment_shader_derivative_hint, _misc_flag1,
- _MISC_FLAG1_BIT);
+ _MISC_FLAG1_BIT);
break;
case GL_GENERATE_MIPMAP_HINT:
STATE_PROC(gl_generate_mipmap_hint, _tex_flag1, _TEX_FLAG1_BIT);
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_polygon_offset_factor, 0, factor) ||
- CURR_STATE_COMPARE(gl_polygon_offset_units, 0, units)) {
+ CURR_STATE_COMPARE(gl_polygon_offset_units, 0, units)) {
IF_GL_SUCCESS(_orig_fastpath_glPolygonOffset(factor, units)) {
current_ctx->_misc_flag1 |=
_MISC_FLAG1_BIT_gl_polygon_offset_factor |
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_sample_coverage_value, 0, value) ||
- CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
+ CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
IF_GL_SUCCESS(_orig_fastpath_glSampleCoverage(value, invert)) {
current_ctx->_misc_flag1 |=
_MISC_FLAG1_BIT_gl_sample_coverage_value |
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_scissor_box, 0, x) ||
- CURR_STATE_COMPARE(gl_scissor_box, 1, y) ||
- CURR_STATE_COMPARE(gl_scissor_box, 2, width) ||
- CURR_STATE_COMPARE(gl_scissor_box, 3, height)) {
+ CURR_STATE_COMPARE(gl_scissor_box, 1, y) ||
+ CURR_STATE_COMPARE(gl_scissor_box, 2, width) ||
+ CURR_STATE_COMPARE(gl_scissor_box, 3, height)) {
IF_GL_SUCCESS(_orig_fastpath_glScissor(x, y, width, height)) {
current_ctx->_misc_flag2 |= _MISC_FLAG2_BIT_gl_scissor_box;
CURR_STATE_UPDATE(gl_scissor_box, 0, x)
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_stencil_func, 0, func) ||
- CURR_STATE_COMPARE(gl_stencil_ref, 0, ref) ||
- CURR_STATE_COMPARE(gl_stencil_value_mask, 0, mask) ||
- CURR_STATE_COMPARE(gl_stencil_back_func, 0, func) ||
- CURR_STATE_COMPARE(gl_stencil_back_ref, 0, ref) ||
- CURR_STATE_COMPARE(gl_stencil_back_value_mask, 0, mask)) {
+ CURR_STATE_COMPARE(gl_stencil_ref, 0, ref) ||
+ CURR_STATE_COMPARE(gl_stencil_value_mask, 0, mask) ||
+ CURR_STATE_COMPARE(gl_stencil_back_func, 0, func) ||
+ CURR_STATE_COMPARE(gl_stencil_back_ref, 0, ref) ||
+ CURR_STATE_COMPARE(gl_stencil_back_value_mask, 0, mask)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilFunc(func, ref, mask)) {
current_ctx->_stencil_flag1 |=
_STENCIL_FLAG1_BIT_gl_stencil_func |
if ((face == GL_FRONT) || (face == GL_FRONT_AND_BACK)) {
if (CURR_STATE_COMPARE(gl_stencil_func, 0, func) ||
- CURR_STATE_COMPARE(gl_stencil_ref, 0, ref) ||
- CURR_STATE_COMPARE(gl_stencil_value_mask, 0, mask)) {
+ CURR_STATE_COMPARE(gl_stencil_ref, 0, ref) ||
+ CURR_STATE_COMPARE(gl_stencil_value_mask, 0, mask)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilFuncSeparate(face, func, ref, mask)) {
current_ctx->_stencil_flag1 |=
_STENCIL_FLAG1_BIT_gl_stencil_func |
}
} else if ((face == GL_BACK) || (face == GL_FRONT_AND_BACK)) {
if (CURR_STATE_COMPARE(gl_stencil_back_func, 0, func) ||
- CURR_STATE_COMPARE(gl_stencil_back_ref, 0, ref) ||
- CURR_STATE_COMPARE(gl_stencil_back_value_mask, 0, mask)) {
+ CURR_STATE_COMPARE(gl_stencil_back_ref, 0, ref) ||
+ CURR_STATE_COMPARE(gl_stencil_back_value_mask, 0, mask)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilFuncSeparate(face, func, ref, mask)) {
current_ctx->_stencil_flag2 |=
_STENCIL_FLAG2_BIT_gl_stencil_back_func |
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_stencil_writemask, 0, mask) ||
- CURR_STATE_COMPARE(gl_stencil_back_writemask, 0, mask)) {
+ CURR_STATE_COMPARE(gl_stencil_back_writemask, 0, mask)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilMask(mask)) {
current_ctx->_stencil_flag1 |= _STENCIL_FLAG1_BIT_gl_stencil_writemask;
current_ctx->_stencil_flag2 |= _STENCIL_FLAG2_BIT_gl_stencil_back_writemask;
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_stencil_fail, 0, fail) ||
- CURR_STATE_COMPARE(gl_stencil_pass_depth_fail, 0, zfail) ||
- CURR_STATE_COMPARE(gl_stencil_pass_depth_pass, 0, zpass) ||
- CURR_STATE_COMPARE(gl_stencil_back_fail, 0, fail) ||
- CURR_STATE_COMPARE(gl_stencil_back_pass_depth_fail, 0, zfail) ||
- CURR_STATE_COMPARE(gl_stencil_back_pass_depth_pass, 0, zpass)) {
+ CURR_STATE_COMPARE(gl_stencil_pass_depth_fail, 0, zfail) ||
+ CURR_STATE_COMPARE(gl_stencil_pass_depth_pass, 0, zpass) ||
+ CURR_STATE_COMPARE(gl_stencil_back_fail, 0, fail) ||
+ CURR_STATE_COMPARE(gl_stencil_back_pass_depth_fail, 0, zfail) ||
+ CURR_STATE_COMPARE(gl_stencil_back_pass_depth_pass, 0, zpass)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilOp(fail, zfail, zpass)) {
current_ctx->_stencil_flag1 |=
_STENCIL_FLAG1_BIT_gl_stencil_fail |
void
fastpath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
- GLenum zpass)
+ GLenum zpass)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
if ((face == GL_FRONT) || (face == GL_FRONT_AND_BACK)) {
if (CURR_STATE_COMPARE(gl_stencil_fail, 0, fail) ||
- CURR_STATE_COMPARE(gl_stencil_pass_depth_fail, 0, zfail) ||
- CURR_STATE_COMPARE(gl_stencil_pass_depth_pass, 0, zpass)) {
+ CURR_STATE_COMPARE(gl_stencil_pass_depth_fail, 0, zfail) ||
+ CURR_STATE_COMPARE(gl_stencil_pass_depth_pass, 0, zpass)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass)) {
current_ctx->_stencil_flag1 |=
_STENCIL_FLAG1_BIT_gl_stencil_fail |
}
} else if ((face == GL_BACK) || (face == GL_FRONT_AND_BACK)) {
if (CURR_STATE_COMPARE(gl_stencil_back_fail, 0, fail) ||
- CURR_STATE_COMPARE(gl_stencil_back_pass_depth_fail, 0, zfail) ||
- CURR_STATE_COMPARE(gl_stencil_back_pass_depth_pass, 0, zpass)) {
+ CURR_STATE_COMPARE(gl_stencil_back_pass_depth_fail, 0, zfail) ||
+ CURR_STATE_COMPARE(gl_stencil_back_pass_depth_pass, 0, zpass)) {
IF_GL_SUCCESS(_orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass)) {
current_ctx->_stencil_flag2 |=
_STENCIL_FLAG2_BIT_gl_stencil_back_fail |
void
fastpath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
+ GLfloat w)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
void
fastpath_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
- GLboolean normalized, GLsizei stride, const void *pointer)
+ GLboolean normalized, GLsizei stride, const void *pointer)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
IF_GL_SUCCESS(_orig_fastpath_glVertexAttribPointer(index, size, type,
- normalized, stride, pointer)) {
+ normalized, stride, pointer)) {
if (current_ctx->gl_vertex_array_binding[0] == 0) {
current_ctx->_vattrib_flag |= _VATTRIB_FLAG_BIT_gl_vertex_array;
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_viewport, 0, x) ||
- CURR_STATE_COMPARE(gl_viewport, 1, y) ||
- CURR_STATE_COMPARE(gl_viewport, 2, width) ||
- CURR_STATE_COMPARE(gl_viewport, 3, height)) {
- IF_GL_SUCCESS(_orig_fastpath_glViewport(x, y, width, height)) {
+ CURR_STATE_COMPARE(gl_viewport, 1, y) ||
+ CURR_STATE_COMPARE(gl_viewport, 2, width) ||
+ CURR_STATE_COMPARE(gl_viewport, 3, height)) {
+ IF_GL_SUCCESS(_orig_fastpath_glViewport(x, y, width, height)) {
current_ctx->_clear_flag1 |= _CLEAR_FLAG1_BIT_gl_viewport;
CURR_STATE_UPDATE(gl_viewport, 0, x)
CURR_STATE_UPDATE(gl_viewport, 1, y)
case GL_VALIDATE_STATUS:
case GL_TESS_CONTROL_SHADER_EXT:
case GL_TESS_EVALUATION_SHADER_EXT:
- case GL_GEOMETRY_SHADER_EXT:{
+ case GL_GEOMETRY_SHADER_EXT: {
GLint real_obj_id = _COREGL_INT_INIT_VALUE;
GLuint glue_obj_id = _COREGL_INT_INIT_VALUE;
GL_Object_Type obj_type = GL_OBJECT_TYPE_UNKNOWN;
/* ES 3.0 PASS (SUPPORT) */
void
fastpath_glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length,
- GLenum *binaryFormat, void *binary)
+ GLenum *binaryFormat, void *binary)
{
GLuint real_obj;
}
_orig_fastpath_glGetProgramBinary(real_obj, bufsize, length, binaryFormat,
- binary);
+ binary);
goto finish;
void
fastpath_glGetProgramBinaryOES(GLuint program, GLsizei bufsize, GLsizei *length,
- GLenum *binaryFormat, void *binary)
+ GLenum *binaryFormat, void *binary)
{
GLuint real_obj;
}
_orig_fastpath_glGetProgramBinaryOES(real_obj, bufsize, length, binaryFormat,
- binary);
+ binary);
goto finish;
void
fastpath_glProgramBinary(GLuint program, GLenum binaryFormat,
- const void *binary, GLint length)
+ const void *binary, GLint length)
{
GLuint real_obj;
void
fastpath_glProgramBinaryOES(GLuint program, GLenum binaryFormat,
- const void *binary, GLint length)
+ const void *binary, GLint length)
{
GLuint real_obj;
current_ctx->_misc_flag3 |= _MISC_FLAG3_BIT_gl_read_buffer;
CURR_STATE_UPDATE(gl_read_buffer, 0, mode)
}
- }
- else if (current_ctx->gl_framebuffer_binding_read[0] && mode == GL_BACK) {
+ } else if (current_ctx->gl_framebuffer_binding_read[0] && mode == GL_BACK) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
IF_GL_SUCCESS(_orig_fastpath_glGenQueries(n, objid_array)) {
for (i = 0; i < n; i++) {
ids[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_QUERY, objid_array[i]);
+ GL_OBJECT_TYPE_QUERY, objid_array[i]);
}
}
if (ids[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_QUERY, ids[i]);
+ GL_OBJECT_TYPE_QUERY, ids[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_QUERY,
- ids[i]) == 1);
+ ids[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glFramebufferTextureLayer(GLenum target, GLenum attachment,
- GLuint texture, GLint level, GLint layer)
+ GLuint texture, GLint level, GLint layer)
{
GLuint real_obj;
IF_GL_SUCCESS(_orig_fastpath_glGenVertexArrays(n, objid_array)) {
for (i = 0; i < n; i++) {
arrays[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_VERTEXARRAY, objid_array[i]);
+ GL_OBJECT_TYPE_VERTEXARRAY, objid_array[i]);
}
}
goto finish;
}
- if(real_obj == 0) {
+ if (real_obj == 0) {
IF_GL_SUCCESS(_orig_fastpath_glBindVertexArray(real_obj)) {
current_ctx->_misc_flag3 &= ~(_MISC_FLAG3_BIT_gl_vertex_array_binding);
CURR_STATE_CLEAR(gl_vertex_array_binding, 0)
- for(i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
+ for (i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
CURR_STATE_CLEAR(gl_vertex_array_enabled, i)
- }
- }
- else if (CURR_STATE_COMPARE(gl_vertex_array_binding, 0, real_obj)) {
+ }
+ } else if (CURR_STATE_COMPARE(gl_vertex_array_binding, 0, real_obj)) {
IF_GL_SUCCESS(_orig_fastpath_glBindVertexArray(real_obj)) {
current_ctx->_misc_flag3 |= _MISC_FLAG3_BIT_gl_vertex_array_binding;
CURR_STATE_UPDATE(gl_vertex_array_binding, 0, real_obj)
- for(i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
+ for (i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
CURR_STATE_CLEAR(gl_vertex_array_enabled, i)
- }
+ }
}
goto finish;
if (arrays[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]);
+ GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]) == 1);
+ GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]) == 1);
objid_array[real_n++] = real_objid;
}
IF_GL_SUCCESS(_orig_fastpath_glGenTransformFeedbacks(n, objid_array)) {
for (i = 0; i < n; i++) {
ids[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_TRANSFORMFEEDBACK, objid_array[i]);
+ GL_OBJECT_TYPE_TRANSFORMFEEDBACK, objid_array[i]);
}
}
current_ctx->_misc_flag3 |= _MISC_FLAG3_BIT_gl_transform_feedback_binding;
CURR_STATE_UPDATE(gl_transform_feedback_binding, 0, real_obj)
}
- }
- else if(current_ctx->gl_transform_feedback_active[0] == GL_TRUE &&
- current_ctx->gl_transform_feedback_paused[0] == GL_FALSE) {
+ } else if (current_ctx->gl_transform_feedback_active[0] == GL_TRUE &&
+ current_ctx->gl_transform_feedback_paused[0] == GL_FALSE) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
if (ids[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_TRANSFORMFEEDBACK, ids[i]);
+ GL_OBJECT_TYPE_TRANSFORMFEEDBACK, ids[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_TRANSFORMFEEDBACK, ids[i]) == 1);
+ GL_OBJECT_TYPE_TRANSFORMFEEDBACK, ids[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glTransformFeedbackVaryings(GLuint program, GLsizei count,
- const GLchar *const *varyings, GLenum bufferMode)
+ const GLchar *const *varyings, GLenum bufferMode)
{
GLuint real_obj;
void
fastpath_glGetTransformFeedbackVarying(GLuint program, GLuint index,
- GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
+ GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
GLuint real_obj;
void
fastpath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
- GLsizei stride, const GLvoid *pointer)
+ GLsizei stride, const GLvoid *pointer)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
IF_GL_SUCCESS(_orig_fastpath_glVertexAttribIPointer(index, size, type, stride,
- pointer)) {
+ pointer)) {
if (current_ctx->gl_vertex_array_binding[0] == 0) {
current_ctx->_vattrib_flag |= _VATTRIB_FLAG_BIT_gl_vertex_array;
void
fastpath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
- GLuint w)
+ GLuint w)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
void
fastpath_glGetUniformIndices(GLuint program, GLsizei uniformCount,
- const GLchar *const *uniformNames, GLuint *uniformIndices)
+ const GLchar *const *uniformNames, GLuint *uniformIndices)
{
GLuint real_obj;
}
_orig_fastpath_glGetUniformIndices(real_obj, uniformCount, uniformNames,
- uniformIndices);
+ uniformIndices);
goto finish;
void
fastpath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
- const GLuint *uniformIndices, GLenum pname, GLint *params)
+ const GLuint *uniformIndices, GLenum pname, GLint *params)
{
GLuint real_obj;
}
_orig_fastpath_glGetActiveUniformsiv(real_obj, uniformCount, uniformIndices,
- pname, params);
+ pname, params);
goto finish;
void
fastpath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
GLuint real_obj;
void
fastpath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
- GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+ GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
{
GLuint real_obj;
void
fastpath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
- GLuint uniformBlockBinding)
+ GLuint uniformBlockBinding)
{
GLuint real_obj;
}
_orig_fastpath_glUniformBlockBinding(real_obj, uniformBlockIndex,
- uniformBlockBinding);
+ uniformBlockBinding);
goto finish;
IF_GL_SUCCESS(_orig_fastpath_glGenSamplers(n, objid_array)) {
for (i = 0; i < n; i++) {
samplers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_SAMPLER, objid_array[i]);
+ GL_OBJECT_TYPE_SAMPLER, objid_array[i]);
}
}
if (samplers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_SAMPLER, samplers[i]);
+ GL_OBJECT_TYPE_SAMPLER, samplers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_SAMPLER,
- samplers[i]) == 1);
+ samplers[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glSamplerParameterfv(GLuint sampler, GLenum pname,
- const GLfloat *param)
+ const GLfloat *param)
{
GLuint real_obj;
/* GLES3.1 API */
GLuint
fastpath_glCreateShaderProgramv(GLenum type, GLsizei count,
- const GLchar *const *strings)
+ const GLchar *const *strings)
{
GLuint ret = 0;
GLuint real_obj = 0;
real_obj = _orig_fastpath_glCreateShaderProgramv(type, count, strings);
if (real_obj != 0) {
ret = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAM, real_obj);
+ GL_OBJECT_TYPE_PROGRAM, real_obj);
Program_object_attached_tag *poat = NULL;
poat = (Program_object_attached_tag *)calloc(1,
poat->shader_count = 0;
fastpath_ostate_set_object_tag(¤t_ctx->ostate, GL_OBJECT_TYPE_PROGRAM,
- ret, poat);
+ ret, poat);
}
_attach_program_object(¤t_ctx->ostate, real_obj);
IF_GL_SUCCESS(_orig_fastpath_glGenProgramPipelines(n, objid_array)) {
for (i = 0; i < n; i++) {
pipelines[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAMPIPELINE, objid_array[i]);
+ GL_OBJECT_TYPE_PROGRAMPIPELINE, objid_array[i]);
}
}
INIT_FASTPATH_GL_FUNC();
if (params == NULL ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_obj) != 1) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
case GL_TESS_EVALUATION_SHADER_EXT:
case GL_GEOMETRY_SHADER_EXT:
IF_GL_SUCCESS(_orig_fastpath_glGetProgramPipelineiv(real_obj, pname, params)) {
- if(pname != GL_INFO_LOG_LENGTH && pname != GL_VALIDATE_STATUS)
+ if (pname != GL_INFO_LOG_LENGTH && pname != GL_VALIDATE_STATUS)
_modify_get_value(pname, params, GL_INT, GL_FALSE);
}
break;
if (pipelines[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAMPIPELINE, pipelines[i]);
+ GL_OBJECT_TYPE_PROGRAMPIPELINE, pipelines[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_PROGRAMPIPELINE, pipelines[i]) == 1);
+ GL_OBJECT_TYPE_PROGRAMPIPELINE, pipelines[i]) == 1);
objid_array[real_n++] = real_objid;
}
void
fastpath_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
- GLsizei *length, GLchar *infoLog)
+ GLsizei *length, GLchar *infoLog)
{
GLuint real_obj;
INIT_FASTPATH_GL_FUNC();
if (NULL == infoLog || bufSize < 0 ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
void
fastpath_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
- GLuint num_groups_z)
+ GLuint num_groups_z)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (num_groups_x > GL_MAX_COMPUTE_WORK_GROUP_COUNT ||
- num_groups_y > GL_MAX_COMPUTE_WORK_GROUP_COUNT ||
- num_groups_z > GL_MAX_COMPUTE_WORK_GROUP_COUNT) {
+ num_groups_y > GL_MAX_COMPUTE_WORK_GROUP_COUNT ||
+ num_groups_z > GL_MAX_COMPUTE_WORK_GROUP_COUNT) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
void
fastpath_glGetProgramInterfaceiv(GLuint program, GLenum programInterface,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
GLuint real_obj;
INIT_FASTPATH_GL_FUNC();
if (params == NULL ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
_orig_fastpath_glGetProgramInterfaceiv(real_obj, programInterface, pname,
- params);
+ params);
goto finish;
GLuint
fastpath_glGetProgramResourceIndex( GLuint program, GLenum programInterface,
- const char *name)
+ const char *name)
{
GLuint real_obj;
GLuint ret = GL_INVALID_INDEX;
INIT_FASTPATH_GL_FUNC();
if (name == NULL ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
void
fastpath_glGetProgramResourceName(GLuint program, GLenum programInterface,
- GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
+ GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
{
GLuint real_obj;
INIT_FASTPATH_GL_FUNC();
if ((NULL == name && 0 != bufSize) || 0 > bufSize ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
_orig_fastpath_glGetProgramResourceName(real_obj, programInterface, index,
- bufSize, length, name);
+ bufSize, length, name);
goto finish;
void
fastpath_glGetProgramResourceiv( GLuint program, GLenum programInterface,
- GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
- GLsizei *length, GLint *params)
+ GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
+ GLsizei *length, GLint *params)
{
GLuint real_obj;
if (0 > bufSize || 0 >= propCount || NULL == props || ((NULL == params &&
0 < bufSize)) ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
_orig_fastpath_glGetProgramResourceiv(real_obj, programInterface, index,
- propCount, props, bufSize, length, params);
+ propCount, props, bufSize, length, params);
goto finish;
GLint
fastpath_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
- GLchar const *name)
+ GLchar const *name)
{
GLuint real_obj;
GLuint ret = -1;
INIT_FASTPATH_GL_FUNC();
if (name == NULL ||
- GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
- if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_pipeline_obj) != 1) {
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline,
+ &real_pipeline_obj) != 1) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
goto finish;
}
- if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline, &real_pipeline_obj) != 1) {
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAMPIPELINE, pipeline,
+ &real_pipeline_obj) != 1) {
_set_gl_error(GL_INVALID_OPERATION);
goto finish;
}
void
fastpath_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
- GLint z)
+ GLint z)
{
GLuint real_obj;
void
fastpath_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
- GLint z, GLint w)
+ GLint z, GLint w)
{
GLuint real_obj;
void
fastpath_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
- GLfloat y)
+ GLfloat y)
{
GLuint real_obj;
void
fastpath_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z)
+ GLfloat y, GLfloat z)
{
GLuint real_obj;
void
fastpath_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z, GLfloat w)
+ GLfloat y, GLfloat z, GLfloat w)
{
GLuint real_obj;
void
fastpath_glProgramUniform3ui(GLuint program, GLint location, GLuint x, GLuint y,
- GLuint z)
+ GLuint z)
{
GLuint real_obj;
void
fastpath_glProgramUniform4ui(GLuint program, GLint location, GLuint x, GLuint y,
- GLuint z, GLuint w)
+ GLuint z, GLuint w)
{
GLuint real_obj;
void
fastpath_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
GLuint real_obj;
void
fastpath_glBindImageTexture(GLuint unit, GLuint texture, GLint level,
- GLboolean layered, GLint layer, GLenum access, GLenum format)
+ GLboolean layered, GLint layer, GLenum access, GLenum format)
{
GLuint real_obj;
}
_orig_fastpath_glBindImageTexture(unit, real_obj, level, layered, layer, access,
- format);
+ format);
goto finish;
void
fastpath_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
- GLint *params)
+ GLint *params)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- IF_GL_SUCCESS(_orig_fastpath_glGetTexLevelParameteriv (target, level, pname, params)) {
+ IF_GL_SUCCESS(_orig_fastpath_glGetTexLevelParameteriv (target, level, pname,
+ params)) {
_modify_get_value(pname, params, GL_INT, GL_FALSE);
}
void
fastpath_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
- GLfloat *params)
+ GLfloat *params)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- IF_GL_SUCCESS(_orig_fastpath_glGetTexLevelParameterfv (target, level, pname, params)) {
+ IF_GL_SUCCESS(_orig_fastpath_glGetTexLevelParameterfv (target, level, pname,
+ params)) {
_modify_get_value(pname, params, GL_FLOAT, GL_FALSE);
}
void
fastpath_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
- GLintptr offset, GLsizei stride)
+ GLintptr offset, GLsizei stride)
{
GLuint real_obj;
} \
}
- switch(target) {
- case GL_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_read_used)
- STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
+ switch (target) {
+ case GL_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_read_used)
+ STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
if (current_ctx->gl_framebuffer_binding_draw_used)
STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
- if(!current_ctx->gl_framebuffer_binding_read_used && !current_ctx->gl_framebuffer_binding_draw_used)
- STATE_PROC(gl_framebuffer_binding, _bind_flag1, _BIND_FLAG1_BIT)
- break;
- case GL_READ_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_read_used)
- STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
+ if (!current_ctx->gl_framebuffer_binding_read_used &&
+ !current_ctx->gl_framebuffer_binding_draw_used)
+ STATE_PROC(gl_framebuffer_binding, _bind_flag1, _BIND_FLAG1_BIT)
+ break;
+ case GL_READ_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_read_used)
+ STATE_PROC(gl_framebuffer_binding_read, _bind_flag1, _BIND_FLAG1_BIT)
break;
- case GL_DRAW_FRAMEBUFFER:
- if (current_ctx->gl_framebuffer_binding_draw_used)
- STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
+ case GL_DRAW_FRAMEBUFFER:
+ if (current_ctx->gl_framebuffer_binding_draw_used)
+ STATE_PROC(gl_framebuffer_binding_draw, _bind_flag1, _BIND_FLAG1_BIT)
break;
- default:
- _set_gl_error(GL_INVALID_ENUM);
- goto finish;
+ default:
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
#undef STATE_PROC
if (framebuffers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
+ GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]) == 1);
+ GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
if (renderbuffers[i] == 0) continue;
real_objid = fastpath_ostate_get_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
+ GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
if (real_objid == 0) continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]) == 1);
+ GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_depth_range, 0, zNear) ||
- CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
+ CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
IF_GL_SUCCESS(_orig_fastpath_glDepthRangefOES(zNear, zFar)) {
current_ctx->_clear_flag2 |= _CLEAR_FLAG2_BIT_gl_depth_range;
CURR_STATE_UPDATE(gl_depth_range, 0, zNear)
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_depth_range, 0, zNear) ||
- CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
+ CURR_STATE_COMPARE(gl_depth_range, 1, zFar)) {
IF_GL_SUCCESS(_orig_fastpath_glDepthRangexOES(zNear, zFar)) {
current_ctx->_clear_flag2 |= _CLEAR_FLAG2_BIT_gl_depth_range;
CURR_STATE_UPDATE(gl_depth_range, 0, zNear)
void
fastpath_glFramebufferRenderbufferOES(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
GLuint real_obj;
void
fastpath_glFramebufferTexture2DOES(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
GLuint real_obj;
IF_GL_SUCCESS(_orig_fastpath_glGenFramebuffersOES(n, objid_array)) {
for (i = 0; i < n; i++) {
framebuffers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
+ GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
}
}
IF_GL_SUCCESS(_orig_fastpath_glGenRenderbuffersOES(n, objid_array)) {
for (i = 0; i < n; i++) {
renderbuffers[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
+ GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
}
}
break;
case GL_RENDERBUFFER:
if (GET_GLUE_OBJ(GL_OBJECT_TYPE_RENDERBUFFER, real_obj,
- (GLuint *)params) != 1) {
+ (GLuint *)params) != 1) {
params[0] = 0;
goto finish;
}
objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
for (i = 0; i < n; i++) {
- GLuint real_obj;
- if (ids[i] == 0)
- continue;
+ GLuint real_obj;
+ if (ids[i] == 0)
+ continue;
- if(GET_REAL_OBJ(GL_OBJECT_TYPE_QUERY, ids[i], &real_obj) != 1)
- continue;
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_QUERY, ids[i], &real_obj) != 1)
+ continue;
- AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_QUERY,
- ids[i]) == 1);
- objid_array[real_n++] = real_obj;
+ AST(fastpath_ostate_remove_object(¤t_ctx->ostate, GL_OBJECT_TYPE_QUERY,
+ ids[i]) == 1);
+ objid_array[real_n++] = real_obj;
}
_orig_fastpath_glDeleteQueriesEXT(real_n, objid_array);
IF_GL_SUCCESS(_orig_fastpath_glGenQueriesEXT(n, objid_array)) {
for (i = 0; i < n; i++) {
ids[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_QUERY, objid_array[i]);
+ GL_OBJECT_TYPE_QUERY, objid_array[i]);
}
}
_BLEND_FLAG_BIT_gl_blend_equation_alpha;
_orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_RGB,
- (GLint *) (current_ctx->gl_blend_equation_rgb));
+ (GLint *) (current_ctx->gl_blend_equation_rgb));
_orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_ALPHA,
- (GLint *) (current_ctx->gl_blend_equation_alpha));
+ (GLint *) (current_ctx->gl_blend_equation_alpha));
}
goto finish;
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_blend_equation_rgb, 0, modeRGB) ||
- CURR_STATE_COMPARE(gl_blend_equation_alpha, 0, modeAlpha)) {
+ CURR_STATE_COMPARE(gl_blend_equation_alpha, 0, modeAlpha)) {
IF_GL_SUCCESS(_orig_fastpath_glBlendEquationSeparateOES(modeRGB, modeAlpha)) {
current_ctx->_blend_flag |=
_BLEND_FLAG_BIT_gl_blend_equation_rgb |
void
fastpath_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
- GLenum dstAlpha)
+ GLenum dstAlpha)
{
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_blend_src_rgb, 0, srcRGB) ||
- CURR_STATE_COMPARE(gl_blend_dst_rgb, 0, dstRGB) ||
- CURR_STATE_COMPARE(gl_blend_src_alpha, 0, srcAlpha) ||
- CURR_STATE_COMPARE(gl_blend_dst_alpha, 0, dstAlpha)) {
+ CURR_STATE_COMPARE(gl_blend_dst_rgb, 0, dstRGB) ||
+ CURR_STATE_COMPARE(gl_blend_src_alpha, 0, srcAlpha) ||
+ CURR_STATE_COMPARE(gl_blend_dst_alpha, 0, dstAlpha)) {
IF_GL_SUCCESS(_orig_fastpath_glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha,
- dstAlpha)) {
+ dstAlpha)) {
current_ctx->_blend_flag |=
_BLEND_FLAG_BIT_gl_blend_src_rgb |
_BLEND_FLAG_BIT_gl_blend_src_alpha |
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_polygon_offset_factor, 0, factor) ||
- CURR_STATE_COMPARE(gl_polygon_offset_units, 0, units)) {
+ CURR_STATE_COMPARE(gl_polygon_offset_units, 0, units)) {
IF_GL_SUCCESS(_orig_fastpath_glPolygonOffsetxOES(factor, units)) {
current_ctx->_misc_flag1 |=
_MISC_FLAG1_BIT_gl_polygon_offset_factor |
INIT_FASTPATH_GL_FUNC();
if (CURR_STATE_COMPARE(gl_sample_coverage_value, 0, value) ||
- CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
+ CURR_STATE_COMPARE(gl_sample_coverage_invert, 0, invert)) {
IF_GL_SUCCESS(_orig_fastpath_glSampleCoveragexOES(value, invert)) {
current_ctx->_misc_flag1 |=
_MISC_FLAG1_BIT_gl_sample_coverage_value |
IF_GL_SUCCESS(_orig_fastpath_glGenVertexArraysOES(n, objid_array)) {
for (i = 0; i < n; i++) {
arrays[i] = fastpath_ostate_create_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_VERTEXARRAY, objid_array[i]);
+ GL_OBJECT_TYPE_VERTEXARRAY, objid_array[i]);
}
}
goto finish;
}
- if(real_obj == 0) {
+ if (real_obj == 0) {
IF_GL_SUCCESS(_orig_fastpath_glBindVertexArrayOES(real_obj)) {
current_ctx->_misc_flag3 &= ~(_MISC_FLAG3_BIT_gl_vertex_array_binding);
CURR_STATE_CLEAR(gl_vertex_array_binding, 0)
- for(i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
+ for (i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
CURR_STATE_CLEAR(gl_vertex_array_enabled, i)
- }
- }
- else if (CURR_STATE_COMPARE(gl_vertex_array_binding, 0, real_obj)) {
+ }
+ } else if (CURR_STATE_COMPARE(gl_vertex_array_binding, 0, real_obj)) {
IF_GL_SUCCESS(_orig_fastpath_glBindVertexArrayOES(real_obj)) {
current_ctx->_misc_flag3 |= _MISC_FLAG3_BIT_gl_vertex_array_binding;
CURR_STATE_UPDATE(gl_vertex_array_binding, 0, real_obj)
- for(i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
+ for (i = 0; i < current_ctx->gl_vertex_attribs_num[0]; i++)
CURR_STATE_CLEAR(gl_vertex_array_enabled, i)
- }
+ }
}
goto finish;
if (arrays[i] == 0)
continue;
- if(GET_REAL_OBJ(GL_OBJECT_TYPE_VERTEXARRAY, arrays[i],&real_objid) != 1)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_VERTEXARRAY, arrays[i], &real_objid) != 1)
continue;
AST(fastpath_ostate_remove_object(¤t_ctx->ostate,
- GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]) == 1);
+ GL_OBJECT_TYPE_VERTEXARRAY, arrays[i]) == 1);
objid_array[real_n++] = real_objid;
}
goto finish;
}
- _orig_fastpath_glBlendEquationi(real_obj, mode);
+ _orig_fastpath_glBlendEquationi(real_obj, mode);
goto finish;
}
void
-fastpath_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+fastpath_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer,
+ GLintptr offset, GLsizeiptr size)
{
GLuint real_obj;
}
void
-fastpath_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
+fastpath_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize,
+ GLfloat *params)
{
GLuint real_obj;
}
void
-fastpath_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
+fastpath_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize,
+ GLint *params)
{
GLuint real_obj;
}
void
-fastpath_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
+fastpath_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize,
+ GLuint *params)
{
GLuint real_obj;
}
void
-fastpath_glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
+fastpath_glSamplerParameterIuiv(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
GLuint real_obj;
}
void
-fastpath_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+fastpath_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture,
+ GLint level)
{
GLuint real_obj;
}
void
-fastpath_glFramebufferTextureOES(GLenum target, GLenum attachment, GLuint texture, GLint level)
+fastpath_glFramebufferTextureOES(GLenum target, GLenum attachment,
+ GLuint texture, GLint level)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glTexBufferRangeOES(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+fastpath_glTexBufferRangeOES(GLenum target, GLenum internalformat,
+ GLuint buffer, GLintptr offset, GLsizeiptr size)
{
GLuint real_obj;
goto finish;
}
- _orig_fastpath_glTexBufferRangeOES(target, internalformat, real_obj, offset, size);
+ _orig_fastpath_glTexBufferRangeOES(target, internalformat, real_obj, offset,
+ size);
goto finish;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
+fastpath_glGetSamplerParameterIivOES(GLuint sampler, GLenum pname,
+ GLint *params)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
+fastpath_glSamplerParameterIivOES(GLuint sampler, GLenum pname,
+ const GLint *param)
{
GLuint real_obj;
}
void
-fastpath_glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
+fastpath_glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname,
+ GLuint *params)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
+fastpath_glSamplerParameterIuivOES(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
+fastpath_glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname,
+ GLint *params)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
+fastpath_glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
+ GLuint *params)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glSamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
+fastpath_glSamplerParameterIivEXT(GLuint sampler, GLenum pname,
+ const GLint *param)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)
+fastpath_glFramebufferTextureEXT(GLenum target, GLenum attachment,
+ GLuint texture, GLint level)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glTexBufferRangeEXT(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+fastpath_glTexBufferRangeEXT(GLenum target, GLenum internalformat,
+ GLuint buffer, GLintptr offset, GLsizeiptr size)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- if(target != GL_TEXTURE_BUFFER_EXT){
+ if (target != GL_TEXTURE_BUFFER_EXT) {
_set_gl_error(GL_INVALID_ENUM);
goto finish;
}
- if (offset < 0 || size<=0){
+ if (offset < 0 || size <= 0) {
_set_gl_error(GL_INVALID_VALUE);
goto finish;
}
goto finish;
}
- _orig_fastpath_glTexBufferRangeEXT(target, internalformat, real_obj, offset, size);
+ _orig_fastpath_glTexBufferRangeEXT(target, internalformat, real_obj, offset,
+ size);
goto finish;
_COREGL_FASTPATH_FUNC_END();
}
void
-fastpath_glSamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
+fastpath_glSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
GLuint real_obj;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- if(target != GL_TEXTURE_BUFFER_EXT)
+ if (target != GL_TEXTURE_BUFFER_EXT)
_set_gl_error(GL_INVALID_ENUM);
if (GET_REAL_OBJ(GL_OBJECT_TYPE_BUFFER, buffer, &real_obj) != 1) {
}
GLUE_STATE(GLuint, gl_draw_buffers_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_units_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, (GLint *)value);)
GLUE_STATE(GLuint, gl_vertex_attribs_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)value);)
GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, (GLint *)value);)
GLUE_STATE(GLuint, gl_uniform_buffer_binding_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, (GLint *)value);)
GLUE_STATE(GLuint, gl_shader_storage_buffer_binding_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, (GLint *)value);)
GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding_num, 1, 1,
- _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, (GLint *)value);)
GLUE_STATE(GLuint, gl_array_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_copy_read_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_COPY_READ_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_COPY_READ_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_copy_write_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_COPY_WRITE_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_COPY_WRITE_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_element_array_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_pixel_pack_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_pixel_unpack_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_uniform_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNIFORM_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNIFORM_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_texture_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_TEXTURE_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_TEXTURE_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_shader_storage_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_ATOMIC_COUNTER_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_ATOMIC_COUNTER_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_draw_indirect_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_DRAW_INDIRECT_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_DRAW_INDIRECT_BUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_dispatch_indirect_buffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, (GLint *)value);)
_COREGL_START_API(COREGL_GLAPI_3)
GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding_array,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_transform_feedback_buffer_binding_array_offset,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings_offset(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_transform_feedback_buffer_binding_array_size,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings_size(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings_size(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_uniform_buffer_binding_array,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_uniform_buffer_binding_array_offset,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_uniform_buffer_binding_array_size,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_shader_storage_buffer_binding_array,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_shader_storage_buffer_binding_array_offset,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_shader_storage_buffer_binding_array_size,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding_array,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_atomic_counter_buffer_binding_array_offset,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_atomic_counter_buffer_binding_array_size,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_uniform_buffer_range_binding_array,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_uniform_buffer_range_binding_array_offset,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_uniform_buffer_range_binding_array_size,
- INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
- _state_get_uniform_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
- _state_get_uniform_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
+ _state_get_uniform_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+ _state_get_uniform_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_transform_feedback_buffer_range_binding_array,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_transform_feedback_buffer_range_binding_array_offset,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings_offset(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_transform_feedback_buffer_range_binding_array_size,
- INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
- MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- _state_get_transform_feedback_buffer_bindings_size(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_transform_feedback_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+ _state_get_transform_feedback_buffer_bindings_size(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_transform_feedback_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_shader_storage_buffer_range_binding_array,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
- MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_shader_storage_buffer_range_binding_array_offset,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
- MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings_offset(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_shader_storage_buffer_range_binding_array_size,
- INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
- MAX_SHADER_STORAGE_BUFFER_BINDINGS,
- _state_get_shader_storage_buffer_bindings_size(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_shader_storage_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_shader_storage_buffer_binding_num[0],
+ MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+ _state_get_shader_storage_buffer_bindings_size(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_shader_storage_buffer_bindings_size(value);)
GLUE_STATE(GLuint, gl_atomic_counter_buffer_range_binding_array,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
- MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings(value);)
GLUE_STATE(GLintptr, gl_atomic_counter_buffer_range_binding_array_offset,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
- MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings_offset(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings_offset(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings_offset(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings_offset(value);)
GLUE_STATE(GLsizeiptr, gl_atomic_counter_buffer_range_binding_array_size,
- INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
- MAX_ATOMIC_COUNTER_BUFFER_BINDING,
- _state_get_atomic_counter_buffer_bindings_size(
- value); /* DEFAULT NOT EFFECT */,
- _state_get_atomic_counter_buffer_bindings_size(value);)
+ INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0],
+ MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+ _state_get_atomic_counter_buffer_bindings_size(
+ value); /* DEFAULT NOT EFFECT */,
+ _state_get_atomic_counter_buffer_bindings_size(value);)
_COREGL_END_API(COREGL_GLAPI_3)
GLUE_STATE(GLuint, gl_framebuffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_framebuffer_binding_read, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_ANGLE, (GLint *)value);)
+ _sym_glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_ANGLE, (GLint *)value);)
GLUE_STATE(GLuint, gl_framebuffer_binding_draw, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_ANGLE, (GLint *)value);)
+ _sym_glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_ANGLE, (GLint *)value);)
GLUE_STATE(GLuint, gl_renderbuffer_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_RENDERBUFFER_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_RENDERBUFFER_BINDING, (GLint *)value);)
GLUE_STATE(GLboolean, gl_blend, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_BLEND, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_BLEND, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_cull_face, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_CULL_FACE, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_CULL_FACE, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_depth_test, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_dither, 1, 1, SET_1(GL_TRUE),
- _sym_glGetBooleanv(GL_DITHER, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_DITHER, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_polygon_offset_fill, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_POLYGON_OFFSET_FILL, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_POLYGON_OFFSET_FILL, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_sample_alpha_to_coverage, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SAMPLE_ALPHA_TO_COVERAGE, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SAMPLE_ALPHA_TO_COVERAGE, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_sample_coverage, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SAMPLE_COVERAGE, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SAMPLE_COVERAGE, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_scissor_test, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SCISSOR_TEST, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SCISSOR_TEST, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_stencil_test, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_STENCIL_TEST, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_STENCIL_TEST, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_sample_shading_oes, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SAMPLE_SHADING_OES, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SAMPLE_SHADING_OES, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_sample_mask, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SAMPLE_MASK, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SAMPLE_MASK, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_primitive_restart_fixed_index, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_PRIMITIVE_RESTART_FIXED_INDEX, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_PRIMITIVE_RESTART_FIXED_INDEX, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_rasterizer_discard, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_RASTERIZER_DISCARD, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_RASTERIZER_DISCARD, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_blend_advanced_coherent_khr, 1, 1, SET_1(GL_TRUE),
- _sym_glGetBooleanv(GL_BLEND_ADVANCED_COHERENT_KHR, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_BLEND_ADVANCED_COHERENT_KHR, (GLboolean *)value);)
GLUE_STATE(GLint, gl_viewport, 4, 4,
- _sym_glGetIntegerv(GL_VIEWPORT, (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_VIEWPORT, (GLint *)value);)
+ _sym_glGetIntegerv(GL_VIEWPORT, (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_VIEWPORT, (GLint *)value);)
GLUE_STATE(GLuint, gl_current_program, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)value);)
+ _sym_glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)value);)
GLUE_STATE(GLclampf, gl_color_clear_value, 4, 4, SET_4(0.0f, 0.0f, 0.0f, 0.0f),
- _sym_glGetFloatv(GL_COLOR_CLEAR_VALUE, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_COLOR_CLEAR_VALUE, (GLfloat *)value);)
GLUE_STATE(GLboolean, gl_color_writemask, 4, 4, SET_4(GL_TRUE, GL_TRUE, GL_TRUE,
- GL_TRUE), _sym_glGetBooleanv(GL_COLOR_WRITEMASK, (GLboolean *)value);)
+ GL_TRUE), _sym_glGetBooleanv(GL_COLOR_WRITEMASK, (GLboolean *)value);)
GLUE_STATE(GLclampf, gl_depth_range, 2, 2, SET_2(0.0f, 1.0f),
- _sym_glGetFloatv(GL_DEPTH_RANGE, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_DEPTH_RANGE, (GLfloat *)value);)
GLUE_STATE(GLclampf, gl_depth_clear_value, 1, 1, SET_1(1.0f),
- _sym_glGetFloatv(GL_DEPTH_CLEAR_VALUE, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_DEPTH_CLEAR_VALUE, (GLfloat *)value);)
GLUE_STATE(GLenum, gl_depth_func, 1, 1, SET_1(GL_LESS),
- _sym_glGetIntegerv(GL_DEPTH_FUNC, (GLint *)value);)
+ _sym_glGetIntegerv(GL_DEPTH_FUNC, (GLint *)value);)
GLUE_STATE(GLboolean, gl_depth_writemask, 1, 1, SET_1(GL_TRUE),
- _sym_glGetBooleanv(GL_DEPTH_WRITEMASK, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_DEPTH_WRITEMASK, (GLboolean *)value);)
GLUE_STATE(GLenum, gl_cull_face_mode, 1, 1, SET_1(GL_BACK),
- _sym_glGetIntegerv(GL_CULL_FACE_MODE, (GLint *)value);)
+ _sym_glGetIntegerv(GL_CULL_FACE_MODE, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_2d_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_BINDING_2D, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_BINDING_2D, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_3d_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_BINDING_3D, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_BINDING_3D, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_2d_array_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_BINDING_2D_ARRAY, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_BINDING_2D_ARRAY, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_cube_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_BINDING_CUBE_MAP, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_BINDING_CUBE_MAP, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_external_oes_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_EXTERNAL_OES, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_EXTERNAL_OES, (GLint *)value);)
GLUE_STATE(GLuint, gl_tex_buffer_ext_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_BUFFER_EXT, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_2d_multisample_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_cube_map_array_ext_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_CUBE_MAP_ARRAY_EXT, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_2d_multisample_array_oes_state, INITIAL_CTX->gl_tex_units_num[0],
- MAX_TEXTURE_UNITS,
- SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
- _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, (GLint *)value);)
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_BUFFER_EXT, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_2d_multisample_state,
+ INITIAL_CTX->gl_tex_units_num[0],
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_cube_map_array_ext_state,
+ INITIAL_CTX->gl_tex_units_num[0],
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_CUBE_MAP_ARRAY_EXT, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_2d_multisample_array_oes_state,
+ INITIAL_CTX->gl_tex_units_num[0],
+ MAX_TEXTURE_UNITS,
+ SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+ _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, (GLint *)value);)
GLUE_STATE(GLenum, gl_active_texture, 1, 1, SET_1(GL_TEXTURE0),
- _sym_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)value))
+ _sym_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)value))
GLUE_STATE(GLenum, gl_client_active_texture, 1, 1, SET_1(GL_TEXTURE0),
- _sym_glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, (GLint *)value))
+ _sym_glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, (GLint *)value))
GLUE_STATE(GLenum, gl_generate_mipmap_hint, 1, 1, SET_1(GL_DONT_CARE),
- _sym_glGetIntegerv(GL_GENERATE_MIPMAP_HINT, (GLint *)value))
+ _sym_glGetIntegerv(GL_GENERATE_MIPMAP_HINT, (GLint *)value))
GLUE_STATE(GLclampf, gl_blend_color, 4, 4, SET_4(0.0f, 0.0f, 0.0f, 0.0f),
- _sym_glGetFloatv(GL_BLEND_COLOR, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_BLEND_COLOR, (GLfloat *)value);)
GLUE_STATE(GLenum, gl_blend_src_rgb, 1, 1, SET_1(GL_ONE),
- _sym_glGetIntegerv(GL_BLEND_SRC_RGB, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_SRC_RGB, (GLint *)value);)
GLUE_STATE(GLenum, gl_blend_src_alpha, 1, 1, SET_1(GL_ONE),
- _sym_glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint *)value);)
GLUE_STATE(GLenum, gl_blend_dst_rgb, 1, 1, SET_1(GL_ZERO),
- _sym_glGetIntegerv(GL_BLEND_DST_RGB, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_DST_RGB, (GLint *)value);)
GLUE_STATE(GLenum, gl_blend_dst_alpha, 1, 1, SET_1(GL_ZERO),
- _sym_glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint *)value);)
GLUE_STATE(GLenum, gl_blend_equation_rgb, 1, 1, SET_1(GL_FUNC_ADD),
- _sym_glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint *)value);)
GLUE_STATE(GLenum, gl_blend_equation_alpha, 1, 1, SET_1(GL_FUNC_ADD),
- _sym_glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint *)value);)
+ _sym_glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_func, 1, 1, SET_1(GL_ALWAYS),
- _sym_glGetIntegerv(GL_STENCIL_FUNC, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_FUNC, (GLint *)value);)
GLUE_STATE(GLint, gl_stencil_ref, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_STENCIL_REF, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_REF, (GLint *)value);)
GLUE_STATE(GLuintmask, gl_stencil_value_mask, 1, 1,
- _sym_glGetIntegerv(GL_STENCIL_VALUE_MASK,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_VALUE_MASK,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_fail, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_FAIL, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_FAIL, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_pass_depth_fail, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_pass_depth_pass, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint *)value);)
GLUE_STATE(GLuintmask, gl_stencil_writemask, 1, 1,
- _sym_glGetIntegerv(GL_STENCIL_WRITEMASK,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_WRITEMASK,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_back_func, 1, 1, SET_1(GL_ALWAYS),
- _sym_glGetIntegerv(GL_STENCIL_BACK_FUNC, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_FUNC, (GLint *)value);)
GLUE_STATE(GLint, gl_stencil_back_ref, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_STENCIL_BACK_REF, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_REF, (GLint *)value);)
GLUE_STATE(GLuintmask, gl_stencil_back_value_mask, 1, 1,
- _sym_glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_back_fail, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_BACK_FAIL, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_FAIL, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_back_pass_depth_fail, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, (GLint *)value);)
GLUE_STATE(GLenum, gl_stencil_back_pass_depth_pass, 1, 1, SET_1(GL_KEEP),
- _sym_glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, (GLint *)value);)
GLUE_STATE(GLuintmask, gl_stencil_back_writemask, 1, 1,
- _sym_glGetIntegerv(GL_STENCIL_BACK_WRITEMASK,
- (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_BACK_WRITEMASK,
+ (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, (GLint *)value);)
GLUE_STATE(GLint, gl_stencil_clear_value, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_STENCIL_CLEAR_VALUE, (GLint *)value);)
+ _sym_glGetIntegerv(GL_STENCIL_CLEAR_VALUE, (GLint *)value);)
// PIXEL FLAG 1
GLUE_STATE(GLint, gl_pack_row_length, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PACK_ROW_LENGTH, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PACK_ROW_LENGTH, (GLint *)value);)
GLUE_STATE(GLint, gl_pack_skip_rows, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PACK_SKIP_ROWS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PACK_SKIP_ROWS, (GLint *)value);)
GLUE_STATE(GLint, gl_pack_skip_pixels, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PACK_SKIP_PIXELS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PACK_SKIP_PIXELS, (GLint *)value);)
GLUE_STATE(GLint, gl_pack_alignment, 1, 1, SET_1(4),
- _sym_glGetIntegerv(GL_PACK_ALIGNMENT, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PACK_ALIGNMENT, (GLint *)value);)
// PIXEL FLAG 2
GLUE_STATE(GLint, gl_unpack_row_length, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNPACK_ROW_LENGTH, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_ROW_LENGTH, (GLint *)value);)
GLUE_STATE(GLint, gl_unpack_skip_rows, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNPACK_SKIP_ROWS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_SKIP_ROWS, (GLint *)value);)
GLUE_STATE(GLint, gl_unpack_skip_pixels, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNPACK_SKIP_PIXELS, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_SKIP_PIXELS, (GLint *)value);)
GLUE_STATE(GLint, gl_unpack_alignment, 1, 1, SET_1(4),
- _sym_glGetIntegerv(GL_UNPACK_ALIGNMENT, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_ALIGNMENT, (GLint *)value);)
GLUE_STATE(GLint, gl_unpack_image_height, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, (GLint *)value);)
GLUE_STATE(GLint, gl_unpack_skip_images, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_UNPACK_SKIP_IMAGES, (GLint *)value);)
+ _sym_glGetIntegerv(GL_UNPACK_SKIP_IMAGES, (GLint *)value);)
// MISC FLAG 1
GLUE_STATE(GLenum, gl_front_face, 1, 1, SET_1(GL_CCW),
- _sym_glGetIntegerv(GL_FRONT_FACE, (GLint *)value);)
+ _sym_glGetIntegerv(GL_FRONT_FACE, (GLint *)value);)
GLUE_STATE(GLfloat, gl_line_width, 1, 1, SET_1(1.0f),
- _sym_glGetFloatv(GL_LINE_WIDTH, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_LINE_WIDTH, (GLfloat *)value);)
GLUE_STATE(GLfloat, gl_polygon_offset_factor, 1, 1, SET_1(0.0f),
- _sym_glGetFloatv(GL_POLYGON_OFFSET_FACTOR, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_POLYGON_OFFSET_FACTOR, (GLfloat *)value);)
GLUE_STATE(GLfloat, gl_polygon_offset_units, 1, 1, SET_1(0.0f),
- _sym_glGetFloatv(GL_POLYGON_OFFSET_UNITS, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_POLYGON_OFFSET_UNITS, (GLfloat *)value);)
GLUE_STATE(GLclampf, gl_sample_coverage_value, 1, 1, SET_1(1.0f),
- _sym_glGetFloatv(GL_SAMPLE_COVERAGE_VALUE, (GLfloat *)value);)
+ _sym_glGetFloatv(GL_SAMPLE_COVERAGE_VALUE, (GLfloat *)value);)
GLUE_STATE(GLboolean, gl_sample_coverage_invert, 1, 1, SET_1(GL_FALSE),
- _sym_glGetBooleanv(GL_SAMPLE_COVERAGE_INVERT, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_SAMPLE_COVERAGE_INVERT, (GLboolean *)value);)
GLUE_STATE(GLenum, gl_fragment_shader_derivative_hint, 1, 1,
- SET_1(GL_DONT_CARE), _sym_glGetIntegerv(GL_FRAGMENT_SHADER_DERIVATIVE_HINT,
- (GLint *)value);)
+ SET_1(GL_DONT_CARE), _sym_glGetIntegerv(GL_FRAGMENT_SHADER_DERIVATIVE_HINT,
+ (GLint *)value);)
// MISC FLAG 2
GLUE_STATE(GLint, gl_scissor_box, 4, 4,
- _sym_glGetIntegerv(GL_SCISSOR_BOX, (GLint *)value); /* DEFAULT NOT EFFECT */,
- _sym_glGetIntegerv(GL_SCISSOR_BOX, (GLint *)value);)
+ _sym_glGetIntegerv(GL_SCISSOR_BOX, (GLint *)value); /* DEFAULT NOT EFFECT */,
+ _sym_glGetIntegerv(GL_SCISSOR_BOX, (GLint *)value);)
GLUE_STATE(GLuint, gl_vertex_array_buf_id,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(0)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(0)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, (GLint *)value);))
GLUE_STATE(GLint, gl_vertex_array_enabled,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_ENABLED, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_ENABLED, (GLint *)value);))
GLUE_STATE(GLint, gl_vertex_array_size, INITIAL_CTX->gl_vertex_attribs_num[0],
- MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(4)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_SIZE, (GLint *)value);))
+ MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(4)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_SIZE, (GLint *)value);))
GLUE_STATE(GLsizei, gl_vertex_array_stride,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_STRIDE, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_STRIDE, (GLint *)value);))
GLUE_STATE(GLenum, gl_vertex_array_type, INITIAL_CTX->gl_vertex_attribs_num[0],
- MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FLOAT)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_TYPE, (GLint *)value);))
+ MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FLOAT)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_TYPE, (GLint *)value);))
GLUE_STATE(GLint, gl_vertex_array_normalized,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, (GLint *)value);))
GLUE_STATE(GLint, gl_vertex_array_integer,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_INTEGER, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_INTEGER, (GLint *)value);))
GLUE_STATE(GLuint, gl_vertex_array_divisor,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
- GL_VERTEX_ATTRIB_ARRAY_DIVISOR, (GLint *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
+ GL_VERTEX_ATTRIB_ARRAY_DIVISOR, (GLint *)value);))
GLUE_STATE(GLvoidptr, gl_vertex_array_pointer,
- INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(NULL)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1,
- _sym_glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER,
- (GLvoidptr *)value);))
+ INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(NULL)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1,
+ _sym_glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER,
+ (GLvoidptr *)value);))
GLUE_STATE(GLfloat, gl_vertex_attrib_value,
- 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0, 1)),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, _sym_glGetVertexAttribfv(i,
- GL_CURRENT_VERTEX_ATTRIB, (GLfloat *)value);))
+ 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0, 1)),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, _sym_glGetVertexAttribfv(i,
+ GL_CURRENT_VERTEX_ATTRIB, (GLfloat *)value);))
_COREGL_START_API(COREGL_GLAPI_3)
GLUE_STATE(GLint, gl_vertex_attrib_value_integer,
- 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
- GET_INT_FROM_FLOAT(1.0f))),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
- GET_INT_FROM_FLOAT(1.0f))))
+ 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
+ GET_INT_FROM_FLOAT(1.0f))),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
+ GET_INT_FROM_FLOAT(1.0f))))
GLUE_STATE(GLuint, gl_vertex_attrib_value_unsigned_integer,
- 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
- GET_UINT_FROM_FLOAT(1.0f))),
- SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
- GET_INT_FROM_FLOAT(1.0f))))
+ 4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
+ GET_UINT_FROM_FLOAT(1.0f))),
+ SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
+ GET_INT_FROM_FLOAT(1.0f))))
// MISC FLAG 3
GLUE_STATE(GLenum, gl_read_buffer, 1, 1, SET_1(GL_BACK),
- _sym_glGetIntegerv(GL_READ_BUFFER, (GLint *)value);)
+ _sym_glGetIntegerv(GL_READ_BUFFER, (GLint *)value);)
GLUE_STATE(GLenum, gl_draw_buffers, INITIAL_CTX->gl_draw_buffers_num[0], 16,
- SET_1(GL_BACK); value++;
- SET_N(INITIAL_CTX->gl_draw_buffers_num[0] - 1, 1, SET_1(GL_NONE)),
- _state_get_draw_buffers(value);)
+ SET_1(GL_BACK); value++;
+ SET_N(INITIAL_CTX->gl_draw_buffers_num[0] - 1, 1, SET_1(GL_NONE)),
+ _state_get_draw_buffers(value);)
GLUE_STATE(GLuint, gl_vertex_array_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_program_pipeline_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_PROGRAM_PIPELINE_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_PROGRAM_PIPELINE_BINDING, (GLint *)value);)
GLUE_STATE(GLuint, gl_transform_feedback_binding, 1, 1, SET_1(0),
- _sym_glGetIntegerv(GL_TRANSFORM_FEEDBACK_BINDING, (GLint *)value);)
+ _sym_glGetIntegerv(GL_TRANSFORM_FEEDBACK_BINDING, (GLint *)value);)
GLUE_STATE(GLboolean, gl_transform_feedback_active, 1, 1, SET_1(0),
- _sym_glGetBooleanv(GL_TRANSFORM_FEEDBACK_ACTIVE, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_TRANSFORM_FEEDBACK_ACTIVE, (GLboolean *)value);)
GLUE_STATE(GLboolean, gl_transform_feedback_paused, 1, 1, SET_1(0),
- _sym_glGetBooleanv(GL_TRANSFORM_FEEDBACK_PAUSED, (GLboolean *)value);)
+ _sym_glGetBooleanv(GL_TRANSFORM_FEEDBACK_PAUSED, (GLboolean *)value);)
_COREGL_END_API(COREGL_GLAPI_3)
#ifdef _COREGL_START_API_DEFINED_INSIDE
int i;
for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_START, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
- i++) {
+ i++) {
_orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
int i;
for (i = 0; i < initial_fake_ctx->gl_uniform_buffer_binding_num[0]; i++) {
_orig_tracepath_glGetIntegeri_v(GL_UNIFORM_BUFFER_START, i,
- (GLint *)¶ms[i]);
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i,
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i,
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i,
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i,
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i,
+ (GLint *)¶ms[i]);
}
}
AST(initial_fake_ctx != NULL);
int i;
- for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
- _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i, (GLint *)¶ms[i]);
+ for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0];
+ i++) {
+ _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i,
+ (GLint *)¶ms[i]);
}
}
#ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
trace_surface_flag = atoi(get_env_setting("COREGL_TRACE_SURFACE"));
trace_surface_sequence_sort_flag = atoi(
- get_env_setting("COREGL_TRACE_SURFACE_SEQUENCE_SORT"));
+ get_env_setting("COREGL_TRACE_SURFACE_SEQUENCE_SORT"));
trace_surface_print_only_flag = atoi(
- get_env_setting("COREGL_TRACE_SURFACE_PRINT_ONLY"));
+ get_env_setting("COREGL_TRACE_SURFACE_PRINT_ONLY"));
{
// COREGL_TRACE_SURFACE_FILTER_PERIOD=40~60
if (trace_surface_print_only_flag == 1)
COREGL_LOG("\E[40;36;1m(PRINT ONLY)\E[0m ");
if (trace_surface_filter_period_begin != 0 ||
- trace_surface_filter_period_end != 0)
+ trace_surface_filter_period_end != 0)
COREGL_LOG("\E[40;36;1m(SURFACE-PERIOD:%d~%d)\E[0m ",
- trace_surface_filter_period_begin, trace_surface_filter_period_end);
+ trace_surface_filter_period_begin, trace_surface_filter_period_end);
if (trace_surface_filter_type == 1)
COREGL_LOG("\E[40;36;1m(SURFACE-TYPE:EGL)\E[0m ");
if (trace_surface_filter_type == 2)
COREGL_LOG("\E[40;36;1m(SURFACE-TYPE:FBO)\E[0m ");
if (trace_surface_filter_handle != 0)
COREGL_LOG("\E[40;36;1m(SURFACE-HANDLE:%p(%ld))\E[0m ",
- (void *)trace_surface_filter_handle, (long int)trace_surface_filter_handle);
+ (void *)trace_surface_filter_handle, (long int)trace_surface_filter_handle);
if (trace_surface_filter_size_w > 0 && trace_surface_filter_size_h > 0)
COREGL_LOG("\E[40;36;1m(SURFACE-SIZE:%dx%d)\E[0m ", trace_surface_filter_size_w,
- trace_surface_filter_size_h);
+ trace_surface_filter_size_h);
}
COREGL_LOG("\E[40;37;1menabled\E[0m\n");
if (unlikely(trace_state_flag != 1)) return;
_sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS,
- (GLint *)initial_fake_ctx->gl_draw_buffers_num);
+ (GLint *)initial_fake_ctx->gl_draw_buffers_num);
_sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
- (GLint *)initial_fake_ctx->gl_tex_units_num);
+ (GLint *)initial_fake_ctx->gl_tex_units_num);
_sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,
- (GLint *)initial_fake_ctx->gl_vertex_attribs_num);
+ (GLint *)initial_fake_ctx->gl_vertex_attribs_num);
_sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
- (GLint *)initial_fake_ctx->gl_transform_feedback_buffer_binding_num);
+ (GLint *)initial_fake_ctx->gl_transform_feedback_buffer_binding_num);
_sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
- (GLint *)initial_fake_ctx->gl_uniform_buffer_binding_num);
+ (GLint *)initial_fake_ctx->gl_uniform_buffer_binding_num);
_sym_glGetError();
if (!force_output) {
TRACE("\n");
TRACE("\E[0;40;34m===================================================================================================================\E[0m\n");
TRACE("\E[40;32;1m State info \E[1;37;1m: <PID = %d> (CURRENT BINDED CONTEXT)\E[0m\n",
- getpid());
+ getpid());
TRACE("\E[0;40;34m===================================================================================================================\E[0m\n");
#define PRINTF_CHAR_GLenum "0x%8X"
static inline void
_add_timeval_period(struct timeval *tv_dst, struct timeval tv_now,
- struct timeval tv_old)
+ struct timeval tv_old)
{
tv_dst->tv_sec += tv_now.tv_sec - tv_old.tv_sec;
tv_dst->tv_usec += 1000000 + (tv_now.tv_usec - tv_old.tv_usec);
} else {
Trace_Data *newitm = NULL;
newitm = (Trace_Data *)calloc(1, td_size);
- strncpy(newitm->name, name, strlen(name) < (sizeof(newitm->name) -1) ? strlen(name) : (sizeof(newitm->name) -1));
+ strncpy(newitm->name, name,
+ strlen(name) < (sizeof(newitm->name) - 1) ? strlen(name) : (sizeof(
+ newitm->name) - 1));
newitm->next = NULL;
if (prev != NULL) {
if (mtd_table == NULL) {
mtd_table = (Memuse_Data **)calloc(1,
- sizeof(Memuse_Data *) * MAX_TRACE_TABLE_SIZE);
+ sizeof(Memuse_Data *) * MAX_TRACE_TABLE_SIZE);
}
mtd = (Memuse_Data *)_get_trace_data((Trace_Data **)mtd_table,
- sizeof(Memuse_Data), desc);
+ sizeof(Memuse_Data), desc);
AST(mtd != NULL);
if (mtd_table == NULL) {
mtd_table = (Memuse_Data **)calloc(1,
- sizeof(Memuse_Data *) * MAX_TRACE_TABLE_SIZE);
+ sizeof(Memuse_Data *) * MAX_TRACE_TABLE_SIZE);
}
mtd = (Memuse_Data *)_get_trace_data((Trace_Data **)mtd_table,
- sizeof(Memuse_Data), desc);
+ sizeof(Memuse_Data), desc);
AST(mtd != NULL);
AST(mtd->memsize == alloc_size);
void *
tracepath_api_trace_begin(const char *funcname, void *hint,
- int trace_total_time)
+ int trace_total_time)
{
Apicall_Data *ftd = NULL;
struct timeval t = TIMEVAL_INIT;
if (tstate) {
if (tstate->ftd_table == NULL) {
tstate->ftd_table = (Apicall_Data **)calloc(1,
- sizeof(Apicall_Data *) * MAX_TRACE_TABLE_SIZE);
+ sizeof(Apicall_Data *) * MAX_TRACE_TABLE_SIZE);
}
ftd = (Apicall_Data *)_get_trace_data((Trace_Data **)tstate->ftd_table,
- sizeof(Apicall_Data), funcname);
+ sizeof(Apicall_Data), funcname);
}
}
if (tstate && (tstate->ftd_table)) {
ftd = (Apicall_Data *)_get_trace_data((Trace_Data **)tstate->ftd_table,
- sizeof(Apicall_Data), funcname);
+ sizeof(Apicall_Data), funcname);
}
}
if (ftd) _add_timeval(&ftd->elapsed_time, elapsed_time);
if (ftd &&
- elapsed_time.tv_sec >= ftd->elapsed_time_max.tv_sec &&
- elapsed_time.tv_usec > ftd->elapsed_time_max.tv_usec) {
+ elapsed_time.tv_sec >= ftd->elapsed_time_max.tv_sec &&
+ elapsed_time.tv_usec > ftd->elapsed_time_max.tv_usec) {
ftd->elapsed_time_max.tv_sec = elapsed_time.tv_sec;
ftd->elapsed_time_max.tv_usec = elapsed_time.tv_usec;
}
total_other_elapsed_time = _get_timeval(other_elapsed_time);
total_other_elapsed_time_period = _get_timeval_period(other_elapsed_time,
- traced_other_elapsed_time);
+ traced_other_elapsed_time);
traced_other_elapsed_time = other_elapsed_time;
tstate = get_current_thread_state();
static Apicall_Data *trace_hint_swap = NULL;
if (trace_hint_swap == NULL)
trace_hint_swap = (Apicall_Data *)_get_trace_data((Trace_Data **)ftd_table,
- sizeof(Apicall_Data), "tracepath_eglSwapBuffers");
+ sizeof(Apicall_Data), "tracepath_eglSwapBuffers");
if (trace_hint_swap != NULL && total_elapsed_time_period > 0) {
swaps_per_sec = (trace_hint_swap->call_count -
- trace_hint_swap->last_call_count) / (total_elapsed_time_period / 1000);
+ trace_hint_swap->last_call_count) / (total_elapsed_time_period / 1000);
}
}
TRACE("\n");
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
TRACE("\E[40;32;1m API call info \E[1;37;1m: <PID = %d> Thread ID = 0x%x [Swaps per Second(P) = %7.2f]\E[0m\n",
- getpid(), tstate->thread_id, swaps_per_sec);
+ getpid(), tstate->thread_id, swaps_per_sec);
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
// highlighted
total_opengl_elapsed_time += _get_timeval(current->total_elapsed_time);
total_opengl_elapsed_time_period += _get_timeval(current->total_elapsed_time) -
- _get_timeval(current->last_total_elapsed_time);
+ _get_timeval(current->last_total_elapsed_time);
current->traced = 0;
if (current->call_count > current->last_call_count) {
double elapsed_time_period = _get_timeval_period(current->elapsed_time,
- current->last_elapsed_time);
+ current->last_elapsed_time);
double elapsed_time_max = _get_timeval(current->elapsed_time_max);
double elapsed_time_per_call_period = elapsed_time_period /
- (current->call_count - current->last_call_count);
+ (current->call_count - current->last_call_count);
char *fname = current->trace_data.name;
if (!strncmp(fname, "tracepath_", 10))
fname = ¤t->trace_data.name[10];
if (elapsed_time_per_call_period >= 0.01 ||
- current->call_count - current->last_call_count > 1000) {
+ current->call_count - current->last_call_count > 1000) {
TRACE("\E[40;37;1m %-39.39s : %10d call(s), %9.3f ms/API, %9.2f ms(MAX), %9.3f ms/API(P)\E[0m\n",
- fname, current->call_count, elapsed_time_per_call, elapsed_time_max,
- elapsed_time_per_call_period);
+ fname, current->call_count, elapsed_time_per_call, elapsed_time_max,
+ elapsed_time_per_call_period);
current->traced = 1;
}
}
fname = ¤t->trace_data.name[10];
TRACE(" %-39.39s : %10d call(s), %9.3f ms/API, %9.2f ms(MAX)\n",
- fname, current->call_count, elapsed_time_per_call, elapsed_time_max);
+ fname, current->call_count, elapsed_time_per_call, elapsed_time_max);
}
current = (Apicall_Data *)current->trace_data.next;
}
if (trace_api_frame_flag == 0) {
TRACE("\E[40;36;1m %-39.39s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
- "TOTAL elapsed Time",
- total_elapsed_time,
- 100.0,
- total_elapsed_time_period,
- 100.0);
+ "TOTAL elapsed Time",
+ total_elapsed_time,
+ 100.0,
+ total_elapsed_time_period,
+ 100.0);
TRACE("\E[40;36;1m %-39.39s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
- "OpenGL elapsed Time",
- total_opengl_elapsed_time,
- total_opengl_elapsed_time * 100.0 / total_elapsed_time,
- total_opengl_elapsed_time_period,
- total_opengl_elapsed_time_period * 100.0 / total_elapsed_time_period);
+ "OpenGL elapsed Time",
+ total_opengl_elapsed_time,
+ total_opengl_elapsed_time * 100.0 / total_elapsed_time,
+ total_opengl_elapsed_time_period,
+ total_opengl_elapsed_time_period * 100.0 / total_elapsed_time_period);
TRACE("\E[40;36;1m %-39.39s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
- "Out of OpenGL elapsed time",
- total_other_elapsed_time,
- total_other_elapsed_time * 100.0 / total_elapsed_time,
- total_other_elapsed_time_period,
- total_other_elapsed_time_period * 100.0 / total_elapsed_time_period);
+ "Out of OpenGL elapsed time",
+ total_other_elapsed_time,
+ total_other_elapsed_time * 100.0 / total_elapsed_time,
+ total_other_elapsed_time_period,
+ total_other_elapsed_time_period * 100.0 / total_elapsed_time_period);
TRACE("\E[40;36;1m %-39.39s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
- "CoreGL API tracing overhead",
- total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time,
- (total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time) *
- 100.0 / total_elapsed_time,
- total_elapsed_time_period - total_opengl_elapsed_time_period -
- total_other_elapsed_time_period,
- (total_elapsed_time_period - total_opengl_elapsed_time_period -
- total_other_elapsed_time_period) * 100.0 / total_elapsed_time_period);
+ "CoreGL API tracing overhead",
+ total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time,
+ (total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time) *
+ 100.0 / total_elapsed_time,
+ total_elapsed_time_period - total_opengl_elapsed_time_period -
+ total_other_elapsed_time_period,
+ (total_elapsed_time_period - total_opengl_elapsed_time_period -
+ total_other_elapsed_time_period) * 100.0 / total_elapsed_time_period);
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
}
int obj_count = current->alloc_count - current->remove_count;
if (obj_count > 0) {
TRACE("\E[40;37;1m %-46.46s : %12d byte(s)(E), %9d object(s) [%9d+/%9d-]\E[0m\n",
- current->trace_data.name, current->memsize, obj_count, current->alloc_count,
- current->remove_count);
+ current->trace_data.name, current->memsize, obj_count, current->alloc_count,
+ current->remove_count);
}
current = (Memuse_Data *)current->trace_data.next;
}
int obj_count = current->alloc_count - current->remove_count;
if (obj_count == 0) {
TRACE(" %-46.46s : %12d byte(s)(E), %9d object(s) [%9d+/%9d-]\n",
- current->trace_data.name, current->memsize, obj_count, current->alloc_count,
- current->remove_count);
+ current->trace_data.name, current->memsize, obj_count, current->alloc_count,
+ current->remove_count);
}
current = (Memuse_Data *)current->trace_data.next;
}
void (*dl_png_destroy_write_struct) (png_structpp png_ptr_ptr,
- png_infopp info_ptr_ptr);
+ png_infopp info_ptr_ptr);
png_infop (*dl_png_create_info_struct) (png_structp png_ptr);
void (*dl_png_init_io) (png_structp png_ptr,
- png_FILE_p fp);
+ png_FILE_p fp);
void (*dl_png_set_IHDR) (png_structp png_ptr,
- png_infop info_ptr,
- png_uint_32 width,
- png_uint_32 height,
- int bit_depth,
- int color_type,
- int interlace_method,
- int compression_method,
- int filter_method);
+ png_infop info_ptr,
+ png_uint_32 width,
+ png_uint_32 height,
+ int bit_depth,
+ int color_type,
+ int interlace_method,
+ int compression_method,
+ int filter_method);
void (*dl_png_set_bKGD) (png_structp png_ptr,
- png_infop info_ptr,
- png_color_16p background);
+ png_infop info_ptr,
+ png_color_16p background);
void (*dl_png_set_bgr) (png_structp png_ptr);
void (*dl_png_write_info) (png_structp png_ptr,
- png_infop info_ptr);
+ png_infop info_ptr);
void (*dl_png_write_image) (png_structp png_ptr,
- png_bytepp image);
+ png_bytepp image);
void (*dl_png_write_end) (png_structp png_ptr,
- png_infop info_ptr);
+ png_infop info_ptr);
static void
_dump_surface(int force_output, int type, const char *position,
- Surface_Data *sdata)
+ Surface_Data *sdata)
{
static int alldumpcount = 0;
unsigned char *data = NULL;
{
if (!png_lib_handle ||
- dl_png_create_write_struct == NULL ||
- dl_png_destroy_write_struct == NULL ||
- dl_png_create_info_struct == NULL ||
- dl_png_init_io == NULL ||
- dl_png_set_IHDR == NULL ||
- dl_png_set_bKGD == NULL ||
- dl_png_set_bgr == NULL ||
- dl_png_write_info == NULL ||
- dl_png_write_image == NULL ||
- dl_png_write_end == NULL) {
+ dl_png_create_write_struct == NULL ||
+ dl_png_destroy_write_struct == NULL ||
+ dl_png_create_info_struct == NULL ||
+ dl_png_init_io == NULL ||
+ dl_png_set_IHDR == NULL ||
+ dl_png_set_bKGD == NULL ||
+ dl_png_set_bgr == NULL ||
+ dl_png_write_info == NULL ||
+ dl_png_write_image == NULL ||
+ dl_png_write_end == NULL) {
COREGL_ERR("Can't trace surface : Failed to use libpng (recommend : 1.2.50-3.4)");
goto finish;
}
if (trace_surface_sequence_sort_flag == 1)
snprintf(name, sizeof(name), "[%d (%06d)%p-%p] %s %04d (%s).png", getpid(),
- alldumpcount,
- sdata->display, sdata->context, sdata->trace_data.name, sdata->dump_count,
- position);
+ alldumpcount,
+ sdata->display, sdata->context, sdata->trace_data.name, sdata->dump_count,
+ position);
else
snprintf(name, sizeof(name), "[%d %p-%p] %s %04d (%s).png", getpid(),
- sdata->display,
- sdata->context, sdata->trace_data.name, sdata->dump_count, position);
+ sdata->display,
+ sdata->context, sdata->trace_data.name, sdata->dump_count, position);
if (!strncmp(sdata->trace_data.name, "EGL", 3) && type != 2) {
// EGL
if (trace_surface_filter_type != 0 &&
- trace_surface_filter_type != 1) goto finish;;
+ trace_surface_filter_type != 1) goto finish;;
if (trace_surface_filter_handle != 0 &&
- trace_surface_filter_handle != (uintptr_t)sdata->surface) goto finish;
+ trace_surface_filter_handle != (uintptr_t)sdata->surface) goto finish;
EGLConfig eglconfig;
GLint asize, rsize, gsize, bsize;
_orig_tracepath_eglQuerySurface(sdata->display, sdata->surface, EGL_WIDTH,
- &width);
+ &width);
_orig_tracepath_eglQuerySurface(sdata->display, sdata->surface, EGL_HEIGHT,
- &height);
+ &height);
_orig_tracepath_eglQuerySurface(sdata->display, sdata->surface, EGL_CONFIG_ID,
- (GLint *)&eglconfig);
+ (GLint *)&eglconfig);
_orig_tracepath_eglGetConfigAttrib(sdata->display, eglconfig, EGL_ALPHA_SIZE,
- &asize);
+ &asize);
_orig_tracepath_eglGetConfigAttrib(sdata->display, eglconfig, EGL_RED_SIZE,
- &rsize);
+ &rsize);
_orig_tracepath_eglGetConfigAttrib(sdata->display, eglconfig, EGL_GREEN_SIZE,
- &gsize);
+ &gsize);
_orig_tracepath_eglGetConfigAttrib(sdata->display, eglconfig, EGL_BLUE_SIZE,
- &bsize);
+ &bsize);
channel = 4;
if (asize == 0) channel = 3;
if (bsize == 0) channel = 2;
if (channel == 2) channel = 3;
if (width <= 0 || height <= 0 || channel <= 0) goto finish;
if (trace_surface_filter_size_w > 0 && trace_surface_filter_size_h > 0 &&
- (trace_surface_filter_size_w != width || trace_surface_filter_size_h != height))
+ (trace_surface_filter_size_w != width || trace_surface_filter_size_h != height))
goto finish;
if ((trace_surface_filter_period_begin > 0 ||
- trace_surface_filter_period_end > 0) &&
- (trace_surface_filter_period_begin > alldumpcount ||
- trace_surface_filter_period_end < alldumpcount)) {
+ trace_surface_filter_period_end > 0) &&
+ (trace_surface_filter_period_begin > alldumpcount ||
+ trace_surface_filter_period_end < alldumpcount)) {
alldumpcount++;
sdata->dump_count++;
goto finish;
if (channel == 3) channel = 4;
TRACE("\E[40;31;1m[[TRACE SURFACE]] : '%s' is dumped (%dx%dx%d).\E[0m\n", name,
- width, height, channel);
+ width, height, channel);
if (trace_surface_print_only_flag == 1 && force_output == 0) {
alldumpcount++;
sdata->dump_count++;
}
data = (unsigned char *)calloc(1,
- width * height * channel * sizeof(unsigned char));
+ width * height * channel * sizeof(unsigned char));
if (data == NULL) {
COREGL_ERR("Can't trace surface : Failed to allocate memory");
goto finish;
switch (channel) {
case 4:
_orig_tracepath_glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE,
- data);
+ data);
break;
//case 3: _orig_tracepath_glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data); break;
case 1:
_orig_tracepath_glReadPixels(0, 0, width, height, GL_ALPHA, GL_UNSIGNED_BYTE,
- data);
+ data);
break;
}
if (sdata->fbo == 0) goto finish;
if (trace_surface_filter_type != 0 &&
- trace_surface_filter_type != 2) goto finish;
+ trace_surface_filter_type != 2) goto finish;
if (trace_surface_filter_handle != 0 &&
- trace_surface_filter_handle != (uintptr_t)sdata->tex &&
- trace_surface_filter_handle != (uintptr_t)sdata->rb) goto finish;
+ trace_surface_filter_handle != (uintptr_t)sdata->tex &&
+ trace_surface_filter_handle != (uintptr_t)sdata->rb) goto finish;
GLint oldfb;
_orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
if (channel == 2) channel = 3;
if (width <= 0 || height <= 0 || channel <= 0) goto finish;
if (trace_surface_filter_size_w > 0 && trace_surface_filter_size_h > 0 &&
- (trace_surface_filter_size_w != width || trace_surface_filter_size_h != height))
+ (trace_surface_filter_size_w != width || trace_surface_filter_size_h != height))
goto finish;
if ((trace_surface_filter_period_begin > 0 ||
- trace_surface_filter_period_end > 0) &&
- (trace_surface_filter_period_begin > alldumpcount ||
- trace_surface_filter_period_end < alldumpcount)) {
+ trace_surface_filter_period_end > 0) &&
+ (trace_surface_filter_period_begin > alldumpcount ||
+ trace_surface_filter_period_end < alldumpcount)) {
alldumpcount++;
sdata->dump_count++;
goto finish;
}
TRACE("\E[40;31;1m[[TRACE SURFACE]] : '%s' is dumped (%dx%dx%d).\E[0m\n", name,
- width, height, channel);
+ width, height, channel);
if (trace_surface_print_only_flag == 1 && force_output == 0) {
alldumpcount++;
sdata->dump_count++;
if (channel == 3) channel = 4;
data = (unsigned char *)calloc(1,
- width * height * channel * sizeof(unsigned char));
+ width * height * channel * sizeof(unsigned char));
if (data == NULL) {
COREGL_ERR("Can't trace surface : Failed to allocate memory");
goto finish;
switch (channel) {
case 4:
_orig_tracepath_glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE,
- data);
+ data);
break;
//case 3: _orig_tracepath_glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data); break;
case 1:
_orig_tracepath_glReadPixels(0, 0, width, height, GL_ALPHA, GL_UNSIGNED_BYTE,
- data);
+ data);
break;
}
}
}
png = dl_png_create_write_struct(PNG_LIBPNG_VER_STRING,
- NULL,
- NULL,
- NULL);
+ NULL,
+ NULL,
+ NULL);
if (png == NULL) {
COREGL_ERR("Can't trace surface : Failed to create write structure of png file");
goto finish;
switch (channel) {
case 4:
dl_png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA,
- PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
break;
//case 3: dl_png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); break;
case 1:
dl_png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_GRAY,
- PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
break;
}
void
tracepath_surface_trace_add(const char *desc, GLDisplay dpy, GLContext ctx,
- GLSurface surf, GLint fbo, GLint tex, GLint rb, GLint tex_w, GLint tex_h,
- GLint tex_format, const char *dump)
+ GLSurface surf, GLint fbo, GLint tex, GLint rb, GLint tex_w, GLint tex_h,
+ GLint tex_format, const char *dump)
{
Surface_Data *std = NULL;
if (std_table == NULL) {
std_table = (Surface_Data **)calloc(1,
- sizeof(Surface_Data *) * MAX_TRACE_TABLE_SIZE);
+ sizeof(Surface_Data *) * MAX_TRACE_TABLE_SIZE);
}
std = (Surface_Data *)_get_trace_data((Trace_Data **)std_table,
- sizeof(Surface_Data), desc);
+ sizeof(Surface_Data), desc);
AST(std != NULL);
while (current != NULL) {
if (current->surface != EGL_NO_SURFACE && current->display != EGL_NO_DISPLAY &&
- current->context != EGL_NO_CONTEXT) {
+ current->context != EGL_NO_CONTEXT) {
if (_orig_tracepath_eglMakeCurrent(current->display, current->surface,
- current->surface, current->context) == EGL_TRUE) {
+ current->surface, current->context) == EGL_TRUE) {
_dump_surface(force_output, type, position, current);
}
}
TRACE("\n");
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
TRACE("\E[40;32;1m Context info \E[1;37;1m: <PID = %d> %s\E[0m\n", getpid(),
- ment);
+ ment);
TRACE("\E[40;34m========================================================================================================================\E[0m\n");
AST(cur_tstate_tm != NULL);
TRACE(" %c Thread [0x%12x] : Surf <D=[%12p] R=[%12p]>",
- (tstate == cur_tstate_tm) ? '*' : ' ',
- cur_tstate->thread_id,
- cur_tstate_tm->surf_draw,
- cur_tstate_tm->surf_read);
+ (tstate == cur_tstate_tm) ? '*' : ' ',
+ cur_tstate->thread_id,
+ cur_tstate_tm->surf_draw,
+ cur_tstate_tm->surf_read);
if (cur_tstate_tm->ctx != NULL) {
TRACE(" EGLCTX=[%12p]\E[0m\n",
- cur_tstate_tm->ctx->handle);
+ cur_tstate_tm->ctx->handle);
} else {
TRACE(" (NOT BINDED TO THREAD)\E[0m\n");
}
while (current != NULL) {
if (cur_tstate_tm->ctx == current) {
TRACE(" -> EGLCTX [%12p] : EGLDPY=[%12p] <MC count [%10d]> <Ref [%2d]>\E[0m\n",
- current->handle,
- current->dpy,
- current->mc_count,
- current->ref_count);
+ current->handle,
+ current->dpy,
+ current->mc_count,
+ current->ref_count);
}
current = current->next;
if (isbinded == 0) {
TRACE(" EGLCTX [%12p] : EGLDPY=[%12p] <MC count [%10d]> <Ref [%2d]>\E[0m\n",
- current->handle,
- current->dpy,
- current->mc_count,
- current->ref_count);
+ current->handle,
+ current->dpy,
+ current->mc_count,
+ current->ref_count);
}
current = current->next;
EGLBoolean
tracepath_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
- EGLint *num_config)
+ EGLint *num_config)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
- EGLConfig *configs, EGLint config_size, EGLint *num_config)
+ EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
EGLBoolean ret = EGL_FALSE;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_eglChooseConfig(dpy, attrib_list, configs, config_size,
- num_config);
+ num_config);
goto finish;
finish:
EGLBoolean
tracepath_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLSurface
tracepath_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativeWindowType win, const EGLint *attrib_list)
+ EGLNativeWindowType win, const EGLint *attrib_list)
{
EGLSurface ret = EGL_NO_SURFACE;
EGLSurface
tracepath_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
- const EGLint *attrib_list)
+ const EGLint *attrib_list)
{
EGLSurface ret = EGL_NO_SURFACE;
EGLSurface
tracepath_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativePixmapType pixmap, const EGLint *attrib_list)
+ EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
EGLSurface ret = EGL_NO_SURFACE;
EGLBoolean
tracepath_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
- EGLint value)
+ EGLint value)
{
EGLBoolean ret = EGL_FALSE;
EGLContext
tracepath_eglCreateContext(EGLDisplay dpy, EGLConfig config,
- EGLContext share_context, const EGLint *attrib_list)
+ EGLContext share_context, const EGLint *attrib_list)
{
EGLContext ret = EGL_NO_CONTEXT;
if (_orig_tracepath_eglDestroyContext == _sym_eglDestroyContext) {
char ment[256];
snprintf(ment, sizeof(ment), "eglDestroyContext completed (EGLCTX=[%12p])",
- ctx);
+ ctx);
_dump_context_info(ment, 1);
}
}
EGLBoolean
tracepath_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
- EGLContext ctx)
+ EGLContext ctx)
{
EGLBoolean ret = EGL_FALSE;
if (_orig_tracepath_eglMakeCurrent == _sym_eglMakeCurrent) {
char ment[256];
snprintf(ment, sizeof(ment),
- "eglMakeCurrent finished (EGLCTX=[%12p] Surf=[D:%12p R:%12p])",
- ctx, draw, read);
+ "eglMakeCurrent finished (EGLCTX=[%12p] Surf=[D:%12p R:%12p])",
+ ctx, draw, read);
_dump_context_info(ment, 0);
}
}
EGLBoolean
tracepath_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface,
- EGLint *rects, EGLint n_rects)
+ EGLint *rects, EGLint n_rects)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglSwapBuffersRegionEXT(EGLDisplay dpy, EGLSurface surface,
- EGLint numRects, const EGLint *rects)
+ EGLint numRects, const EGLint *rects)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
- EGLNativePixmapType target)
+ EGLNativePixmapType target)
{
EGLBoolean ret = EGL_FALSE;
ret = _orig_tracepath_eglGetProcAddress(procname);
if (ret != NULL) {
COREGL_WRN("\E[40;31;1mTRACEPATH can't support '%s' (tracing for this function will be ignored)\E[0m\n",
- procname);
+ procname);
}
goto finish;
EGLImageKHR
tracepath_eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target,
- EGLClientBuffer buffer, const EGLint *attrib_list)
+ EGLClientBuffer buffer, const EGLint *attrib_list)
{
void *ret = NULL;
void *
tracepath_eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type,
- EGLint access_option)
+ EGLint access_option)
{
void *ret = NULL;
EGLBoolean
tracepath_eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image,
- EGLint device_type)
+ EGLint device_type)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image,
- EGLint attribute, EGLint *value)
+ EGLint attribute, EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface,
- const EGLint *attrib_list)
+ const EGLint *attrib_list)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglQueryWaylandBufferWL(EGLDisplay dpy, void *buffer,
- EGLint attribute, EGLint *value)
+ EGLint attribute, EGLint *value)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface,
- EGLint *rects, EGLint n_rects)
+ EGLint *rects, EGLint n_rects)
{
EGLBoolean ret = EGL_FALSE;
EGLBoolean
tracepath_eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface,
- EGLint *rects, EGLint n_rects)
+ EGLint *rects, EGLint n_rects)
{
EGLBoolean ret = EGL_FALSE;
static void
_add_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type,
- int width, int height, int bpp, const char *format)
+ int width, int height, int bpp, const char *format)
{
Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
if (data == NULL) {
// Update
char ment[MAX_TRACE_NAME_LENGTH];
snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
- data->height,
- data->format);
+ data->height,
+ data->format);
_COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
}
{
char ment[MAX_TRACE_NAME_LENGTH];
snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
- data->height,
- data->format);
+ data->height,
+ data->format);
_COREGL_TRACE_MEM_ADD(ment, data->width * data->height * data->bpp);
}
goto finish;
Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
if (data == NULL) {
COREGL_WRN("\E[40;31;1mError deleting %s object %d. (is not created)\E[0m\n",
- obj_type, obj_idx);
+ obj_type, obj_idx);
return;
}
{
char ment[MAX_TRACE_NAME_LENGTH];
snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
- data->height,
- data->format);
+ data->height,
+ data->format);
_COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
}
#ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
void
_surface_trace_set(int set, GLint fbname, GLenum attachment,
- MY_MODULE_TSTATE *tstate)
+ MY_MODULE_TSTATE *tstate)
{
int atttype = _COREGL_INT_INIT_VALUE;
_orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
char name[256];
snprintf(name, sizeof(name), "FBOTEX_0x%X", attname);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
+ tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
}
break;
case GL_RENDERBUFFER:
char name[256];
snprintf(name, sizeof(name), "FBORB_0x%X", attname);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
+ tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
}
break;
}
char name[256];
snprintf(name, sizeof(name), "FBOTEX_0x%X", attname);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
+ tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
}
break;
case GL_RENDERBUFFER:
char name[256];
snprintf(name, sizeof(name), "FBORB_0x%X", attname);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
+ tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
}
break;
}
}
void
-tracepath_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+tracepath_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFrustumf(left, right, bottom, top, zNear, zFar);
}
void
-tracepath_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+tracepath_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r,
+ GLfloat q)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiTexCoord4f(target, s, t, r, q);
}
void
-tracepath_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+tracepath_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glOrthof(left, right, bottom, top, zNear, zFar);
}
void
-tracepath_glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
+tracepath_glClearColorx(GLclampx red, GLclampx green, GLclampx blue,
+ GLclampx alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearColorx(red, green, blue, alpha);
}
void
-tracepath_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glColorPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glColorPointer(size, type, stride, pointer);
}
void
-tracepath_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+tracepath_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFrustumx(left, right, bottom, top, zNear, zFar);
}
void
-tracepath_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+tracepath_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r,
+ GLfixed q)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiTexCoord4x(target, s, t, r, q);
}
void
-tracepath_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+tracepath_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glOrthox(left, right, bottom, top, zNear, zFar);
}
void
-tracepath_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexCoordPointer(size, type, stride, pointer);
}
void
-tracepath_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glVertexPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexPointer(size, type, stride, pointer);
/* Khronos GLES 1.1 CTS requires glPointSizePointerOES as shared library symbol.*/
void
-tracepath_glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glPointSizePointerOES(GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glPointSizePointerOES(type, stride, pointer);
/* GLES 1.1 extensions */
void
-tracepath_glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
+tracepath_glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width,
+ GLshort height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawTexsOES(x, y, z, width, height);
}
void
-tracepath_glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
+tracepath_glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width,
+ GLfixed height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawTexxOES(x, y, z, width, height);
}
void
-tracepath_glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
+tracepath_glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width,
+ GLfloat height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawTexfOES(x, y, z, width, height);
}
void
-tracepath_glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMatrixIndexPointerOES(size, type, stride, pointer);
}
void
-tracepath_glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+tracepath_glWeightPointerOES(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glWeightPointerOES(size, type, stride, pointer);
/* common extensions in GLES1.1 and GLES2.0 */
void
-tracepath_glRenderbufferStorageMultisampleAPPLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+tracepath_glRenderbufferStorageMultisampleAPPLE(GLenum target, GLsizei samples,
+ GLenum internalformat, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height);
+ _orig_tracepath_glRenderbufferStorageMultisampleAPPLE(target, samples,
+ internalformat, width, height);
goto finish;
}
void
-tracepath_glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
+tracepath_glMultiDrawArraysEXT(GLenum mode, const GLint *first,
+ const GLsizei *count, GLsizei primcount)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiDrawArraysEXT(mode, first, count, primcount);
}
void
-tracepath_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount)
+tracepath_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
+ const void *const *indices, GLsizei primcount)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiDrawElementsEXT(mode, count, type, indices, primcount);
}
void
-tracepath_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+tracepath_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples,
+ GLenum internalformat, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
+ _orig_tracepath_glRenderbufferStorageMultisampleIMG(target, samples,
+ internalformat, width, height);
goto finish;
}
void
-tracepath_glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+tracepath_glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment,
+ GLenum textarget, GLuint texture, GLint level, GLsizei samples)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
+ _orig_tracepath_glFramebufferTexture2DMultisampleIMG(target, attachment,
+ textarget, texture, level, samples);
goto finish;
void
tracepath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendColor(red, green, blue, alpha);
void
tracepath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
- GLenum dstAlpha)
+ GLenum dstAlpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
void
tracepath_glBufferData(GLenum target, GLsizeiptr size, const void *data,
- GLenum usage)
+ GLenum usage)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBufferData(target, size, data, usage);
void
tracepath_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
- const void *data)
+ const void *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBufferSubData(target, offset, size, data);
void
tracepath_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
- GLclampf alpha)
+ GLclampf alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearColor(red, green, blue, alpha);
void
tracepath_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
- GLboolean alpha)
+ GLboolean alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glColorMask(red, green, blue, alpha);
void
tracepath_glCompressedTexImage2D(GLenum target, GLint level,
- GLenum internalformat, GLsizei width, GLsizei height, GLint border,
- GLsizei imageSize, const void *data)
+ GLenum internalformat, GLsizei width, GLsizei height, GLint border,
+ GLsizei imageSize, const void *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width,
- height, border, imageSize, data);
+ height, border, imageSize, data);
goto finish;
void
tracepath_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
- const void *data)
+ GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
+ const void *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset,
void
tracepath_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
- GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+ GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width,
- height, border);
+ height, border);
goto finish;
void
tracepath_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y,
- width, height);
+ width, height);
goto finish;
for (int i = 0; i < n; i++) {
if (renderbuffers[i] == 0) continue;
_remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
- "Renderbuffer");
+ "Renderbuffer");
}
}
}
char name[256];
EGLint btype;
_orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
if (btype == EGL_SINGLE_BUFFER)
snprintf(name, sizeof(name), "EGLPIXMAP_%p",
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
else
snprintf(name, sizeof(name), "EGLWINDOW_%p",
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
- _orig_tracepath_eglGetCurrentContext(),
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
+ _orig_tracepath_eglGetCurrentContext(),
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
}
}
#endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
void
tracepath_glDrawElements(GLenum mode, GLsizei count, GLenum type,
- const void *indices)
+ const void *indices)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawElements(mode, count, type, indices);
char name[256];
EGLint btype;
_orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
if (btype == EGL_SINGLE_BUFFER)
snprintf(name, sizeof(name), "EGLPIXMAP_%p",
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
else
snprintf(name, sizeof(name), "EGLWINDOW_%p",
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
- _orig_tracepath_eglGetCurrentContext(),
- _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
+ _orig_tracepath_eglGetCurrentContext(),
+ _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
}
}
#endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
void
tracepath_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glFramebufferTexture2D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
#endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
_orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture,
- level);
+ level);
#ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
tracepath_fbdump_update(1);
for (int i = 0; i < n; i++) {
if (renderbuffers[i] == 0) continue;
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
- "Renderbuffer", 0, 0, 0, "Unknown");
+ "Renderbuffer", 0, 0, 0, "Unknown");
}
}
}
for (int i = 0; i < n; i++) {
if (textures[i] == 0) continue;
_add_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture", 0, 0,
- 0, "Unknown");
+ 0, "Unknown");
}
}
}
void
tracepath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type,
- name);
+ name);
goto finish;
void
tracepath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ GLsizei *length, GLint *size, GLenum *type, char *name)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type,
- name);
+ name);
goto finish;
void
tracepath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count,
- GLuint *shaders)
+ GLuint *shaders)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
void
tracepath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
void
tracepath_glGetRenderbufferParameteriv(GLenum target, GLenum pname,
- GLint *params)
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
void
tracepath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
void
tracepath_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
- GLint *range, GLint *precision)
+ GLint *range, GLint *precision)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range,
void
tracepath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *source)
+ char *source)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
void
tracepath_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
- GLenum format, GLenum type, void *pixels)
+ GLenum format, GLenum type, void *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
void
tracepath_glRenderbufferStorage(GLenum target, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
}
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
- height, bpp, formatment);
+ height, bpp, formatment);
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
char name[256];
snprintf(name, sizeof(name), "FBORB_%d", objidx);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
+ tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
}
}
}
void
tracepath_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
- const void *binary, GLsizei length)
+ const void *binary, GLsizei length)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
void
tracepath_glShaderSource(GLuint shader, GLsizei count, const char **string,
- const GLint *length)
+ const GLint *length)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glShaderSource(shader, count, string, length);
void
tracepath_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
- GLuint mask)
+ GLuint mask)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
void
tracepath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
- GLenum zpass)
+ GLenum zpass)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
void
tracepath_glTexImage2D(GLenum target, GLint level, GLint internalformat,
- GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
- const void *pixels)
+ GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
+ const void *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexImage2D(target, level, internalformat, width, height,
- border, format, type, pixels);
+ border, format, type, pixels);
goto finish;
}
_add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", width,
- height, bpp, formatment);
+ height, bpp, formatment);
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
char name[256];
snprintf(name, sizeof(name), "FBOTEX_0x%X", objidx);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
+ tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
}
}
}
void
tracepath_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
- const void *pixels)
+ GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
+ const void *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height,
- format, type, pixels);
+ format, type, pixels);
goto finish;
void
tracepath_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
+ GLfloat w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4f(location, x, y, z, w);
void
tracepath_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
void
tracepath_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
void
tracepath_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
void
tracepath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
+ GLfloat w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib4f(index, x, y, z, w);
void
tracepath_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
- GLboolean normalized, GLsizei stride, const void *pointer)
+ GLboolean normalized, GLsizei stride, const void *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribPointer(index, size, type, normalized, stride,
- pointer);
+ pointer);
goto finish;
void
tracepath_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
- GLsizei count, GLenum type, const GLvoid *indices)
+ GLsizei count, GLenum type, const GLvoid *indices)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawRangeElements(mode, start, end, count, type, indices);
void
tracepath_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat,
- GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
- GLenum type, const GLvoid *pixels)
+ GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
+ GLenum type, const GLvoid *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexImage3D(target, level, GLinternalFormat, width, height,
- depth, border, format, type, pixels);
+ depth, border, format, type, pixels);
goto finish;
void
tracepath_glTexImage3DOES(GLenum target, GLint level, GLenum GLinternalFormat,
- GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
- GLenum type, const void *pixels)
+ GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
+ GLenum type, const void *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexImage3DOES(target, level, GLinternalFormat, width, height,
- depth, border, format, type, pixels);
+ depth, border, format, type, pixels);
goto finish;
void
tracepath_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLenum type, const GLvoid *pixels)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLenum type, const GLvoid *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
- height, depth, format, type, pixels);
+ height, depth, format, type, pixels);
goto finish;
void
tracepath_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLenum type, const GLvoid *pixels)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLenum type, const GLvoid *pixels)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
- width, height, depth, format, type, pixels);
+ width, height, depth, format, type, pixels);
goto finish;
void
tracepath_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x,
- y, width, height);
+ y, width, height);
goto finish;
void
tracepath_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
- x, y, width, height);
+ x, y, width, height);
goto finish;
void
tracepath_glCompressedTexImage3D(GLenum target, GLint level,
- GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLsizei imageSize, const GLvoid *data)
+ GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLsizei imageSize, const GLvoid *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexImage3D(target, level, GLinternalformat, width,
- height, depth, border, imageSize, data);
+ height, depth, border, imageSize, data);
goto finish;
void
tracepath_glCompressedTexImage3DOES(GLenum target, GLint level,
- GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLsizei imageSize, const GLvoid *data)
+ GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLsizei imageSize, const GLvoid *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexImage3DOES(target, level, GLinternalformat,
void
tracepath_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLsizei imageSize, const GLvoid *data)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLsizei imageSize, const GLvoid *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexSubImage3D(target, level, xoffset, yoffset,
void
tracepath_glCompressedTexSubImage3DOES(GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
- GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
+ GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
+ GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset,
void
tracepath_glUniformMatrix2x3fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix2x3fv(location, count, transpose, value);
void
tracepath_glUniformMatrix3x2fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix3x2fv(location, count, transpose, value);
void
tracepath_glUniformMatrix2x4fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix2x4fv(location, count, transpose, value);
void
tracepath_glUniformMatrix4x2fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix4x2fv(location, count, transpose, value);
void
tracepath_glUniformMatrix3x4fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix3x4fv(location, count, transpose, value);
void
tracepath_glUniformMatrix4x3fv(GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix4x3fv(location, count, transpose, value);
void
tracepath_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
- GLenum filter)
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
+ GLenum filter)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
- dstX1, dstY1, mask, filter);
+ dstX1, dstY1, mask, filter);
goto finish;
}
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
- height, bpp, formatment);
+ height, bpp, formatment);
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
char name[256];
snprintf(name, sizeof(name), "FBORB_0x%X", objidx);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
+ tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
}
}
}
}
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
- height, bpp, formatment);
+ height, bpp, formatment);
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
char name[256];
snprintf(name, sizeof(name), "FBORB_0x%X", objidx);
tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
- tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
+ tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
}
}
}
void
tracepath_glFramebufferTextureLayer(GLenum target, GLenum attachment,
- GLuint texture, GLint level, GLint layer)
+ GLuint texture, GLint level, GLint layer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
GLvoid *
tracepath_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
- GLbitfield access)
+ GLbitfield access)
{
GLvoid *ret = NULL;
void
tracepath_glFlushMappedBufferRange(GLenum target, GLintptr offset,
- GLsizeiptr length)
+ GLsizeiptr length)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFlushMappedBufferRange(target, offset, length);
void
tracepath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
- GLintptr offset, GLsizeiptr size)
+ GLintptr offset, GLsizeiptr size)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindBufferRange(target, index, buffer, offset, size);
void
tracepath_glTransformFeedbackVaryings(GLuint program, GLsizei count,
- const GLchar *const *varyings, GLenum bufferMode)
+ const GLchar *const *varyings, GLenum bufferMode)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTransformFeedbackVaryings(program, count, varyings,
void
tracepath_glGetTransformFeedbackVarying(GLuint program, GLuint index,
- GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
+ GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTransformFeedbackVarying(program, index, bufSize, length,
void
tracepath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
- GLsizei stride, const GLvoid *pointer)
+ GLsizei stride, const GLvoid *pointer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribIPointer(index, size, type, stride, pointer);
void
tracepath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
- GLuint w)
+ GLuint w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribI4ui(index, x, y, z, w);
void
tracepath_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2,
- GLuint v3)
+ GLuint v3)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4ui(location, v0, v1, v2, v3);
void
tracepath_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
- GLint stencil)
+ GLint stencil)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearBufferfi(buffer, drawbuffer, depth, stencil);
void
tracepath_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget,
- GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+ GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyBufferSubData(readTarget, writeTarget, readOffset,
- writeOffset, size);
+ writeOffset, size);
goto finish;
void
tracepath_glGetUniformIndices(GLuint program, GLsizei uniformCount,
- const GLchar *const *uniformNames, GLuint *uniformIndices)
+ const GLchar *const *uniformNames, GLuint *uniformIndices)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetUniformIndices(program, uniformCount, uniformNames,
- uniformIndices);
+ uniformIndices);
goto finish;
void
tracepath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
- const GLuint *uniformIndices, GLenum pname, GLint *params)
+ const GLuint *uniformIndices, GLenum pname, GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveUniformsiv(program, uniformCount, uniformIndices,
- pname, params);
+ pname, params);
goto finish;
void
tracepath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname,
void
tracepath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
- GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+ GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
void
tracepath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
- GLuint uniformBlockBinding)
+ GLuint uniformBlockBinding)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformBlockBinding(program, uniformBlockIndex,
- uniformBlockBinding);
+ uniformBlockBinding);
goto finish;
void
tracepath_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
- GLsizei instanceCount)
+ GLsizei instanceCount)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawArraysInstanced(mode, first, count, instanceCount);
void
tracepath_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
- const GLvoid *indices, GLsizei instanceCount)
+ const GLvoid *indices, GLsizei instanceCount)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawElementsInstanced(mode, count, type, indices,
- instanceCount);
+ instanceCount);
goto finish;
void
tracepath_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize,
- GLsizei *length, GLint *values)
+ GLsizei *length, GLint *values)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSynciv(sync, pname, bufSize, length, values);
void
tracepath_glSamplerParameterfv(GLuint sampler, GLenum pname,
- const GLfloat *param)
+ const GLfloat *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterfv(sampler, pname, param);
void
tracepath_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
- GLenum *binaryFormat, GLvoid *binary)
+ GLenum *binaryFormat, GLvoid *binary)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramBinary(program, bufSize, length, binaryFormat,
- binary);
+ binary);
goto finish;
void
tracepath_glGetProgramBinaryOES(GLuint program, GLsizei bufSize,
- GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
+ GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramBinaryOES(program, bufSize, length, binaryFormat,
- binary);
+ binary);
goto finish;
void
tracepath_glProgramBinary(GLuint program, GLenum binaryFormat,
- const GLvoid *binary, GLsizei length)
+ const GLvoid *binary, GLsizei length)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
void
tracepath_glProgramBinaryOES(GLuint program, GLenum binaryFormat,
- const GLvoid *binary, GLsizei length)
+ const GLvoid *binary, GLsizei length)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramBinaryOES(program, binaryFormat, binary, length);
void
tracepath_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments)
+ const GLenum *attachments)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glInvalidateFramebuffer(target, numAttachments, attachments);
void
tracepath_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments,
- const GLenum *attachments)
+ const GLenum *attachments)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
void
tracepath_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
+ const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glInvalidateSubFramebuffer(target, numAttachments, attachments,
void
tracepath_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage2D(target, levels, internalformat, width, height);
void
tracepath_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height, GLsizei depth)
+ GLsizei width, GLsizei height, GLsizei depth)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage3D(target, levels, internalformat, width, height,
- depth);
+ depth);
goto finish;
void
tracepath_glGetInternalformativ(GLenum target, GLenum internalformat,
- GLenum pname, GLsizei bufSize, GLint *params)
+ GLenum pname, GLsizei bufSize, GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetInternalformativ(target, internalformat, pname, bufSize,
- params);
+ params);
goto finish;
AST(objidx != _COREGL_INT_INIT_VALUE);
_add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", 0, 0, 0,
- "Unknown");
+ "Unknown");
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
AST(objidx != _COREGL_INT_INIT_VALUE);
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", 0, 0,
- 0, "Unknown");
+ 0, "Unknown");
}
}
#endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
void
tracepath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages,
- GLuint program)
+ GLuint program)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUseProgramStagesEXT(pipeline, stages, program);
GLuint
tracepath_glCreateShaderProgramvEXT(GLenum type, GLsizei count,
- const char **strings)
+ const char **strings)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
void
tracepath_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname,
- GLint *params)
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramPipelineivEXT(pipeline, pname, params);
void
tracepath_glProgramUniform2iEXT(GLuint program, GLint location, GLint x,
- GLint y)
+ GLint y)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2iEXT(program, location, x, y);
void
tracepath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x,
- GLint y, GLint z)
+ GLint y, GLint z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3iEXT(program, location, x, y, z);
void
tracepath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x,
- GLint y, GLint z, GLint w)
+ GLint y, GLint z, GLint w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4iEXT(program, location, x, y, z, w);
void
tracepath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y)
+ GLfloat y)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2fEXT(program, location, x, y);
void
tracepath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z)
+ GLfloat y, GLfloat z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3fEXT(program, location, x, y, z);
void
tracepath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z, GLfloat w)
+ GLfloat y, GLfloat z, GLfloat w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4fEXT(program, location, x, y, z, w);
void
tracepath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform1ivEXT(program, location, count, value);
void
tracepath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2ivEXT(program, location, count, value);
void
tracepath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3ivEXT(program, location, count, value);
void
tracepath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4ivEXT(program, location, count, value);
void
tracepath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform1fvEXT(program, location, count, value);
void
tracepath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2fvEXT(program, location, count, value);
void
tracepath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3fvEXT(program, location, count, value);
void
tracepath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4fvEXT(program, location, count, value);
void
tracepath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix2fvEXT(program, location, count,
void
tracepath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix3fvEXT(program, location, count,
void
tracepath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix4fvEXT(program, location, count,
void
tracepath_glFramebufferTexture3DOES(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+ GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFramebufferTexture3DOES(target, attachment, textarget,
/* GLES3.1 API */
void
tracepath_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
- GLsizei *length, GLchar *infoLog)
+ GLsizei *length, GLchar *infoLog)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
GLuint
tracepath_glCreateShaderProgramv(GLenum type, GLsizei count,
- const GLchar *const *strings)
+ const GLchar *const *strings)
{
GLboolean ret = GL_FALSE;
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
- GLuint num_groups_z)
+ GLuint num_groups_z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
void
tracepath_glDrawElementsIndirect(GLenum mode, GLenum type,
- GLvoid const *indirect)
+ GLvoid const *indirect)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawElementsIndirect(mode, type, indirect);
void
tracepath_glGetFramebufferParameteriv( GLenum target, GLenum pname,
- GLint *params)
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetFramebufferParameteriv(target, pname, params);
void
tracepath_glGetProgramInterfaceiv(GLuint program, GLenum programInterface,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramInterfaceiv(program, programInterface, pname,
- params);
+ params);
goto finish;
GLuint
tracepath_glGetProgramResourceIndex( GLuint program, GLenum programInterface,
- const char *name)
+ const char *name)
{
GLuint ret = GL_INVALID_INDEX;
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glGetProgramResourceName(GLuint program, GLenum programInterface,
- GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
+ GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glGetProgramResourceiv( GLuint program, GLenum programInterface,
- GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
- GLsizei *length, GLint *params)
+ GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize,
+ GLsizei *length, GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramResourceiv(program, programInterface, index,
- propCount, props, bufSize, length, params);
+ propCount, props, bufSize, length, params);
goto finish;
GLint
tracepath_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
- GLchar const *name)
+ GLchar const *name)
{
GLuint ret = -1;
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform1iv(program, location, count, value);
void
tracepath_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2iv(program, location, count, value);
void
tracepath_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3iv(program, location, count, value);
void
tracepath_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4iv(program, location, count, value);
void
tracepath_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform1fv(program, location, count, value);
void
tracepath_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2fv(program, location, count, value);
void
tracepath_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3fv(program, location, count, value);
void
tracepath_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4fv(program, location, count, value);
void
tracepath_glProgramUniformMatrix2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix2fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix3fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix4fv(program, location, count, transpose,
void
tracepath_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
- GLint z)
+ GLint z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3i(program, location, x, y, z);
void
tracepath_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
- GLint z, GLint w)
+ GLint z, GLint w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4i(program, location, x, y, z, w);
void
tracepath_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
- GLfloat y)
+ GLfloat y)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2f(program, location, x, y);
void
tracepath_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z)
+ GLfloat y, GLfloat z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3f(program, location, x, y, z);
void
tracepath_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
- GLfloat y, GLfloat z, GLfloat w)
+ GLfloat y, GLfloat z, GLfloat w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4f(program, location, x, y, z, w);
void
tracepath_glProgramUniform2ui(GLuint program, GLint location, GLuint x,
- GLuint y)
+ GLuint y)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2ui(program, location, x, y);
void
tracepath_glProgramUniform3ui(GLuint program, GLint location, GLuint x,
- GLuint y, GLuint z)
+ GLuint y, GLuint z)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3ui(program, location, x, y, z);
void
tracepath_glProgramUniform4ui(GLuint program, GLint location, GLuint x,
- GLuint y, GLuint z, GLuint w)
+ GLuint y, GLuint z, GLuint w)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4ui(program, location, x, y, z, w);
void
tracepath_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform1uiv(program, location, count, value);
void
tracepath_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform2uiv(program, location, count, value);
void
tracepath_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform3uiv(program, location, count, value);
void
tracepath_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniform4uiv(program, location, count, value);
void
tracepath_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix2x3fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix3x2fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix4x2fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix2x4fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix3x4fv(program, location, count, transpose,
void
tracepath_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
- GLsizei count, GLboolean transpose, const GLfloat *value)
+ GLsizei count, GLboolean transpose, const GLfloat *value)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramUniformMatrix4x3fv(program, location, count, transpose,
void
tracepath_glBindImageTexture(GLuint unit, GLuint texture, GLint level,
- GLboolean layered, GLint layer, GLenum access, GLenum format)
+ GLboolean layered, GLint layer, GLenum access, GLenum format)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindImageTexture(unit, texture, level, layered, layer, access,
- format);
+ format);
goto finish;
void
tracepath_glTexStorage2DMultisample (GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height,
- GLboolean fixedsamplelocations)
+ GLenum internalformat, GLsizei width, GLsizei height,
+ GLboolean fixedsamplelocations)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage2DMultisample (target, samples, internalformat,
void
tracepath_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
- GLint *params)
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTexLevelParameteriv (target, level, pname, params);
void
tracepath_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
- GLfloat *params)
+ GLfloat *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTexLevelParameterfv (target, level, pname, params);
void
tracepath_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
- GLintptr offset, GLsizei stride)
+ GLintptr offset, GLsizei stride)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindVertexBuffer (bindingindex, buffer, offset, stride);
void tracepath_glVertexAttribFormat (GLuint attribindex, GLint size,
- GLenum type, GLboolean normalized, GLuint relativeoffset)
+ GLenum type, GLboolean normalized, GLuint relativeoffset)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribFormat (attribindex, size, type, normalized,
- relativeoffset);
+ relativeoffset);
goto finish;
}
void tracepath_glVertexAttribIFormat (GLuint attribindex, GLint size,
- GLenum type, GLuint relativeoffset)
+ GLenum type, GLuint relativeoffset)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
for (int i = 0; i < n; i++) {
if (renderbuffers[i] == 0) continue;
_remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
- "Renderbuffer");
+ "Renderbuffer");
}
}
}
void
tracepath_glFramebufferRenderbufferOES(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
void
tracepath_glFramebufferTexture2DOES(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
for (int i = 0; i < n; i++) {
if (renderbuffers[i] == 0) continue;
_add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
- "Renderbuffer", 0, 0, 0, "Unknown");
+ "Renderbuffer", 0, 0, 0, "Unknown");
}
}
}
}
void tracepath_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB,
- GLenum srcAlpha, GLenum dstAlpha)
+ GLenum srcAlpha, GLenum dstAlpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
void tracepath_glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue,
- GLclampx alpha)
+ GLclampx alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearColorxOES(red, green, blue, alpha);
}
void tracepath_glColor4xOES(GLfixed red, GLfixed green, GLfixed blue,
- GLfixed alpha)
+ GLfixed alpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glColor4xOES(red, green, blue, alpha);
}
void tracepath_glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom,
- GLfixed top, GLfixed zNear, GLfixed zFar)
+ GLfixed top, GLfixed zNear, GLfixed zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFrustumxOES(left, right, bottom, top, zNear, zFar);
}
void tracepath_glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom,
- GLfloat top, GLfloat zNear, GLfloat zFar)
+ GLfloat top, GLfloat zNear, GLfloat zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFrustumfOES(left, right, bottom, top, zNear, zFar);
}
void tracepath_glGetTexParameterxvOES(GLenum target, GLenum pname,
- GLfixed *params)
+ GLfixed *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTexParameterxvOES(target, pname, params);
void
tracepath_glMultiTexCoord4bOES (GLenum target, GLbyte s, GLbyte t, GLbyte r,
- GLbyte q)
+ GLbyte q)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiTexCoord4bOES (target, s, t, r, q);
void
tracepath_glMultiTexCoord4xOES (GLenum target, GLfixed s, GLfixed t, GLfixed r,
- GLfixed q)
+ GLfixed q)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glMultiTexCoord4xOES (target, s, t, r, q);
void
tracepath_glOrthofOES (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
- GLfloat zNear, GLfloat zFar)
+ GLfloat zNear, GLfloat zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glOrthofOES (left, right, bottom, top, zNear, zFar);
void
tracepath_glOrthoxOES (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
- GLfixed zNear, GLfixed zFar)
+ GLfixed zNear, GLfixed zFar)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glOrthoxOES (left, right, bottom, top, zNear, zFar);
void
tracepath_glRenderbufferStorageOES (GLenum target, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glRenderbufferStorageOES (target, internalformat, width,
void
tracepath_glTexParameterxvOES (GLenum target, GLenum pname,
- const GLfixed *params)
+ const GLfixed *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameterxvOES (target, pname, params);
void
tracepath_glTexStorage2DEXT (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height)
+ GLenum internalformat, GLsizei width, GLsizei height)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage2DEXT (target, levels, internalformat, width,
- height);
+ height);
goto finish;
void
tracepath_glTexStorage3DEXT (GLenum target, GLsizei levels,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage3DEXT (target, levels, internalformat, width,
- height, depth);
+ height, depth);
goto finish;
void
tracepath_glTexStorage3DMultisampleOES (GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
- GLboolean fixedsamplelocations)
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLboolean fixedsamplelocations)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexStorage3DMultisampleOES (target, samples, internalformat,
void tracepath_glDebugMessageControlKHR(GLenum source, GLenum type,
- GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled)
+ GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDebugMessageControlKHR(source, type, severity, count, ids,
}
void tracepath_glDebugMessageInsertKHR(GLenum source, GLenum type, GLuint id,
- GLenum severity, GLsizei length, GLchar const *buf)
+ GLenum severity, GLsizei length, GLchar const *buf)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDebugMessageInsertKHR(source, type, id, severity, length,
- buf);
+ buf);
goto finish;
}
void tracepath_glGetObjectLabelKHR(GLenum identifier, GLuint name,
- GLsizei bufSize, GLsizei *length, GLchar *label)
+ GLsizei bufSize, GLsizei *length, GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetObjectLabelKHR(identifier, name, bufSize, length, label);
}
void tracepath_glGetObjectPtrLabelKHR(void const *ptr, GLsizei bufSize,
- GLsizei *length, GLchar *label)
+ GLsizei *length, GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
void
tracepath_glObjectLabelKHR (GLenum identifier, GLuint name, GLsizei length,
- const GLchar *label)
+ const GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glObjectLabelKHR (identifier, name, length, label);
void
tracepath_glObjectPtrLabelKHR (const void *ptr, GLsizei length,
- const GLchar *label)
+ const GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glObjectPtrLabelKHR (ptr, length, label);
void
tracepath_glPushDebugGroupKHR (GLenum source, GLuint id, GLsizei length,
- const GLchar *message)
+ const GLchar *message)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glPushDebugGroupKHR (source, id, length, message);
}
void
-tracepath_glCopyImageSubData (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)
+tracepath_glCopyImageSubData (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)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+ _orig_tracepath_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY,
+ srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
+ srcDepth);
goto finish;
finish:
}
void
-tracepath_glDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
+tracepath_glDebugMessageControl (GLenum source, GLenum type, GLenum severity,
+ GLsizei count, const GLuint *ids, GLboolean enabled)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glDebugMessageControl (source, type, severity, count, ids, enabled);
+ _orig_tracepath_glDebugMessageControl (source, type, severity, count, ids,
+ enabled);
goto finish;
finish:
}
void
-tracepath_glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
+tracepath_glDebugMessageInsert(GLenum source, GLenum type, GLuint id,
+ GLenum severity, GLsizei length, const GLchar *buf)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDebugMessageInsert(source, type, id, severity, length, buf);
}
GLuint
-tracepath_glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
+tracepath_glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources,
+ GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths,
+ GLchar *messageLog)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
_COREGL_TRACEPATH_FUNC_BEGIN();
- ret = _orig_tracepath_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+ ret = _orig_tracepath_glGetDebugMessageLog(count, bufSize, sources, types, ids,
+ severities, lengths, messageLog);
goto finish;
finish:
}
void
-tracepath_glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
+tracepath_glPushDebugGroup(GLenum source, GLuint id, GLsizei length,
+ const GLchar *message)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glPushDebugGroup(source, id, length, message);
}
void
-tracepath_glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
+tracepath_glObjectLabel(GLenum identifier, GLuint name, GLsizei length,
+ const GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glObjectLabel(identifier, name, length, label);
goto finish;
- finish:
+finish:
_COREGL_TRACEPATH_FUNC_END();
}
void
-tracepath_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
+tracepath_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
+ GLsizei *length, GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetObjectLabel(identifier, name, bufSize, length, label);
}
void
-tracepath_glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
+tracepath_glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length,
+ GLchar *label)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetObjectPtrLabel(ptr, bufSize, length, label);
}
void
-tracepath_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+tracepath_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB,
+ GLenum srcAlpha, GLenum dstAlpha)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void
-tracepath_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+tracepath_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b,
+ GLboolean a)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glColorMaski(index, r, g, b, a);
}
void
-tracepath_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
+tracepath_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const void *indices, GLint basevertex)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
+ _orig_tracepath_glDrawElementsBaseVertex(mode, count, type, indices,
+ basevertex);
goto finish;
finish:
}
void
-tracepath_glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
+tracepath_glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+ GLsizei count, GLenum type, const void *indices, GLint basevertex)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+ _orig_tracepath_glDrawRangeElementsBaseVertex(mode, start, end, count, type,
+ indices, basevertex);
goto finish;
finish:
}
void
-tracepath_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
+tracepath_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count,
+ GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+ _orig_tracepath_glDrawElementsInstancedBaseVertex(mode, count, type, indices,
+ instancecount, basevertex);
goto finish;
finish:
}
void
-tracepath_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+tracepath_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture,
+ GLint level)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFramebufferTexture(target, attachment, texture, level);
}
void
-tracepath_glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
+tracepath_glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ,
+ GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
+ _orig_tracepath_glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ,
+ maxW);
goto finish;
finish:
}
void
-tracepath_glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
+tracepath_glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type, GLsizei bufSize, void *data)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
void
-tracepath_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
+tracepath_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize,
+ GLfloat *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetnUniformfv(program, location, bufSize, params);
}
void
-tracepath_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
+tracepath_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize,
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetnUniformiv(program, location, bufSize, params);
}
void
-tracepath_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
+tracepath_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize,
+ GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetnUniformuiv(program, location, bufSize, params);
}
void
-tracepath_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
+tracepath_glSamplerParameterIiv(GLuint sampler, GLenum pname,
+ const GLint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIiv(sampler, pname, param);
}
void
-tracepath_glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
+tracepath_glSamplerParameterIuiv(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIuiv(sampler, pname, param);
}
void
-tracepath_glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
+tracepath_glGetSamplerParameterIuiv(GLuint sampler, GLenum pname,
+ GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSamplerParameterIuiv(sampler, pname, params);
}
void
-tracepath_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+tracepath_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer,
+ GLintptr offset, GLsizeiptr size)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexBufferRange(target, internalformat, buffer, offset, size);
}
void
-tracepath_glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
+tracepath_glTexStorage3DMultisample(GLenum target, GLsizei samples,
+ GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+ GLboolean fixedsamplelocations)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+ _orig_tracepath_glTexStorage3DMultisample(target, samples, internalformat,
+ width, height, depth, fixedsamplelocations);
goto finish;
finish:
}
void
-tracepath_glFramebufferTextureOES(GLenum target, GLenum attachment, GLuint texture, GLint level)
+tracepath_glFramebufferTextureOES(GLenum target, GLenum attachment,
+ GLuint texture, GLint level)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
tracepath_fbdump_update(0);
#endif
- _orig_tracepath_glFramebufferTextureOES(target, attachment,texture, level);
+ _orig_tracepath_glFramebufferTextureOES(target, attachment, texture, level);
#ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
tracepath_fbdump_update(1);
}
void
-tracepath_glTexBufferRangeOES(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+tracepath_glTexBufferRangeOES(GLenum target, GLenum internalformat,
+ GLuint buffer, GLintptr offset, GLsizeiptr size)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glTexBufferRangeOES(target, internalformat, buffer, offset, size);
+ _orig_tracepath_glTexBufferRangeOES(target, internalformat, buffer, offset,
+ size);
goto finish;
finish:
}
void
-tracepath_glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
+tracepath_glSamplerParameterIuivOES(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIuivOES(sampler, pname, param);
}
void
-tracepath_glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
+tracepath_glSamplerParameterIivOES(GLuint sampler, GLenum pname,
+ const GLint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIivOES(sampler, pname, param);
}
void
-tracepath_glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
+tracepath_glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname,
+ GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSamplerParameterIuivOES(sampler, pname, params);
}
void
-tracepath_glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
+tracepath_glGetSamplerParameterIivOES(GLuint sampler, GLenum pname,
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSamplerParameterIivOES(sampler, pname, params);
}
void
-tracepath_glTexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
+tracepath_glTexParameterIuivOES(GLenum target, GLenum pname,
+ const GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameterIuivOES(target, pname, params);
}
void
-tracepath_glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
+tracepath_glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname,
+ GLint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSamplerParameterIivEXT(sampler, pname, params);
}
void
-tracepath_glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
+tracepath_glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
+ GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetSamplerParameterIuivEXT(sampler, pname, params);
}
void
-tracepath_glSamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
+tracepath_glSamplerParameterIivEXT(GLuint sampler, GLenum pname,
+ const GLint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIivEXT(sampler, pname, param);
}
void
-tracepath_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)
+tracepath_glFramebufferTextureEXT(GLenum target, GLenum attachment,
+ GLuint texture, GLint level)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
tracepath_fbdump_update(0);
#endif
- _orig_tracepath_glFramebufferTextureEXT(target, attachment,texture, level);
+ _orig_tracepath_glFramebufferTextureEXT(target, attachment, texture, level);
#ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
tracepath_fbdump_update(1);
}
void
-tracepath_glTexBufferRangeEXT(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+tracepath_glTexBufferRangeEXT(GLenum target, GLenum internalformat,
+ GLuint buffer, GLintptr offset, GLsizeiptr size)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
- _orig_tracepath_glTexBufferRangeEXT(target, internalformat, buffer, offset, size);
+ _orig_tracepath_glTexBufferRangeEXT(target, internalformat, buffer, offset,
+ size);
goto finish;
finish:
}
void
-tracepath_glSamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
+tracepath_glSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
+ const GLuint *param)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSamplerParameterIuivEXT(sampler, pname, param);
}
void
-tracepath_glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
+tracepath_glTexParameterIuivEXT(GLenum target, GLenum pname,
+ const GLuint *params)
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameterIuivEXT(target, pname, params);
/* Allocate and initialize png_ptr struct for reading, and any other memory. */
extern PNG_EXPORT(png_structp, png_create_read_struct)
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
- png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
+ png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
/* Allocate and initialize png_ptr struct for writing, and any other memory */
extern PNG_EXPORT(png_structp, png_create_write_struct)
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
- png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
+ png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
#ifdef PNG_WRITE_SUPPORTED
extern PNG_EXPORT(png_uint_32, png_get_compression_buffer_size)
#ifdef PNG_USER_MEM_SUPPORTED
extern PNG_EXPORT(png_structp, png_create_read_struct_2)
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
- png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
extern PNG_EXPORT(png_structp, png_create_write_struct_2)
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
- png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
#endif
/* Write a PNG chunk - size, type, (optional) data, CRC. */
/* Free all memory used by the read (old method - NOT DLL EXPORTED) */
extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_infop end_info_ptr)) PNG_DEPRECATED;
+ png_infop end_info_ptr)) PNG_DEPRECATED;
/* Free any memory associated with the png_struct and the png_info_structs */
extern PNG_EXPORT(void, png_destroy_write_struct)
#if defined(USE_FAR_KEYWORD) /* memory model conversion function */
extern void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr,
- int check));
+ int check));
#endif /* USE_FAR_KEYWORD */
#ifndef PNG_NO_ERROR_TEXT
extern PNG_EXPORT(png_charp, png_get_copyright) PNGARG((png_structp png_ptr));
extern PNG_EXPORT(png_charp, png_get_header_ver) PNGARG((png_structp png_ptr));
extern PNG_EXPORT(png_charp,
- png_get_header_version) PNGARG((png_structp png_ptr));
+ png_get_header_version) PNGARG((png_structp png_ptr));
extern PNG_EXPORT(png_charp, png_get_libpng_ver) PNGARG((png_structp png_ptr));
#ifdef PNG_MNG_FEATURES_SUPPORTED
/* pngset.c */
extern PNG_EXPORT(void, png_set_mmx_thresholds)
PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,
- png_uint_32 mmx_rowbytes_threshold));
+ png_uint_32 mmx_rowbytes_threshold));
#endif /* PNG_1_0_X */
/* Free any memory that info_ptr points to and reset struct. */
PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
- png_infop info_ptr)) PNG_PRIVATE;
+ png_infop info_ptr)) PNG_PRIVATE;
#ifndef PNG_1_0_X
/* Function to allocate memory for zlib. */
PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items,
- uInt size)) PNG_PRIVATE;
+ uInt size)) PNG_PRIVATE;
/* Function to free memory for zlib */
PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)) PNG_PRIVATE;
/* Write the "data" buffer to whatever output you are using. */
PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,
- png_size_t length)) PNG_PRIVATE;
+ png_size_t length)) PNG_PRIVATE;
/* Read data from whatever input you are using into the "data" buffer */
PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
- png_size_t length)) PNG_PRIVATE;
+ png_size_t length)) PNG_PRIVATE;
/* Read bytes into buf, and update png_ptr->crc */
PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
- png_size_t length)) PNG_PRIVATE;
+ png_size_t length)) PNG_PRIVATE;
/* Decompress data in a chunk that uses compression */
#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \
/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)
- PNG_PRIVATE);
+ PNG_PRIVATE);
/* Read the CRC from the file and compare it to the libpng calculated CRC */
PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)) PNG_PRIVATE;
* information.
*/
PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
- png_uint_32 height,
- int bit_depth, int color_type, int compression_method, int filter_method,
- int interlace_method)) PNG_PRIVATE;
+ png_uint_32 height,
+ int bit_depth, int color_type, int compression_method, int filter_method,
+ int interlace_method)) PNG_PRIVATE;
PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,
- png_uint_32 num_pal)) PNG_PRIVATE;
+ png_uint_32 num_pal)) PNG_PRIVATE;
PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
- png_size_t length)) PNG_PRIVATE;
+ png_size_t length)) PNG_PRIVATE;
PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)) PNG_PRIVATE;
#ifdef PNG_WRITE_sBIT_SUPPORTED
PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,
- int color_type)) PNG_PRIVATE;
+ int color_type)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_cHRM_SUPPORTED
#ifdef PNG_FLOATING_POINT_SUPPORTED
PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
- double white_x, double white_y,
- double red_x, double red_y, double green_x, double green_y,
- double blue_x, double blue_y)) PNG_PRIVATE;
+ double white_x, double white_y,
+ double red_x, double red_y, double green_x, double green_y,
+ double blue_x, double blue_y)) PNG_PRIVATE;
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
#ifdef PNG_WRITE_sRGB_SUPPORTED
PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
- int intent)) PNG_PRIVATE;
+ int intent)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_iCCP_SUPPORTED
PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
- png_charp name, int compression_type,
- png_charp profile, int proflen)) PNG_PRIVATE;
+ png_charp name, int compression_type,
+ png_charp profile, int proflen)) PNG_PRIVATE;
/* Note to maintainer: profile should be png_bytep */
#endif
#ifdef PNG_WRITE_sPLT_SUPPORTED
PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
- png_sPLT_tp palette)) PNG_PRIVATE;
+ png_sPLT_tp palette)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_tRNS_SUPPORTED
PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
- png_color_16p values, int number, int color_type)) PNG_PRIVATE;
+ png_color_16p values, int number, int color_type)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_bKGD_SUPPORTED
PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
- png_color_16p values, int color_type)) PNG_PRIVATE;
+ png_color_16p values, int color_type)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_hIST_SUPPORTED
PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
- int num_hist)) PNG_PRIVATE;
+ int num_hist)) PNG_PRIVATE;
#endif
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
#ifdef PNG_WRITE_tEXt_SUPPORTED
PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,
- png_charp text, png_size_t text_len)) PNG_PRIVATE;
+ png_charp text, png_size_t text_len)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_zTXt_SUPPORTED
PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,
- png_charp text, png_size_t text_len, int compression)) PNG_PRIVATE;
+ png_charp text, png_size_t text_len, int compression)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_iTXt_SUPPORTED
PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
- int compression, png_charp key, png_charp lang, png_charp lang_key,
- png_charp text)) PNG_PRIVATE;
+ int compression, png_charp key, png_charp lang, png_charp lang_key,
+ png_charp text)) PNG_PRIVATE;
#endif
#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */
PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
- png_infop info_ptr, png_textp text_ptr, int num_text)) PNG_PRIVATE;
+ png_infop info_ptr, png_textp text_ptr, int num_text)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_oFFs_SUPPORTED
PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
- png_int_32 x_offset, png_int_32 y_offset, int unit_type)) PNG_PRIVATE;
+ png_int_32 x_offset, png_int_32 y_offset, int unit_type)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_pCAL_SUPPORTED
PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
- png_int_32 X0, png_int_32 X1, int type, int nparams,
- png_charp units, png_charpp params)) PNG_PRIVATE;
+ png_int_32 X0, png_int_32 X1, int type, int nparams,
+ png_charp units, png_charpp params)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_pHYs_SUPPORTED
PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
- png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
- int unit_type)) PNG_PRIVATE;
+ png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
+ int unit_type)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_tIME_SUPPORTED
PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
- png_timep mod_time)) PNG_PRIVATE;
+ png_timep mod_time)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_sCAL_SUPPORTED
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,
- int unit, double width, double height)) PNG_PRIVATE;
+ int unit, double width, double height)) PNG_PRIVATE;
#else
#ifdef PNG_FIXED_POINT_SUPPORTED
PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
- int unit, png_charp width, png_charp height)) PNG_PRIVATE;
+ int unit, png_charp width, png_charp height)) PNG_PRIVATE;
#endif
#endif
#endif
/* Combine a row of data, dealing with alpha, etc. if requested */
PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
- int mask)) PNG_PRIVATE;
+ int mask)) PNG_PRIVATE;
#ifdef PNG_READ_INTERLACING_SUPPORTED
/* Expand an interlaced row */
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
#ifdef PNG_READ_PACK_SUPPORTED
PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_SHIFT_SUPPORTED
PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,
- png_color_8p sig_bits)) PNG_PRIVATE;
+ png_color_8p sig_bits)) PNG_PRIVATE;
#endif
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_16_TO_8_SUPPORTED
PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_DITHER_SUPPORTED
PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,
- png_bytep row, png_bytep palette_lookup,
- png_bytep dither_lookup)) PNG_PRIVATE;
+ png_bytep row, png_bytep palette_lookup,
+ png_bytep dither_lookup)) PNG_PRIVATE;
# ifdef PNG_CORRECT_PALETTE_SUPPORTED
PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info,
- png_bytep row)) PNG_PRIVATE;
+ png_bytep row)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_PACK_SUPPORTED
PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
- png_bytep row, png_uint_32 bit_depth)) PNG_PRIVATE;
+ png_bytep row, png_uint_32 bit_depth)) PNG_PRIVATE;
#endif
#ifdef PNG_WRITE_SHIFT_SUPPORTED
PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,
- png_color_8p bit_depth)) PNG_PRIVATE;
+ png_color_8p bit_depth)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_BACKGROUND_SUPPORTED
#ifdef PNG_READ_GAMMA_SUPPORTED
PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,
- png_bytep gamma_table, png_uint_16pp gamma_16_table,
- int gamma_shift)) PNG_PRIVATE;
+ png_bytep gamma_table, png_uint_16pp gamma_16_table,
+ int gamma_shift)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_EXPAND_SUPPORTED
png_bytep row, png_colorp palette, png_bytep trans,
int num_trans)) PNG_PRIVATE;
PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
- png_bytep row, png_color_16p trans_value)) PNG_PRIVATE;
+ png_bytep row, png_color_16p trans_value)) PNG_PRIVATE;
#endif
/* The following decodes the appropriate chunks, and does error correction,
/* Decode the IHDR chunk */
PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length));
+ png_uint_32 length));
PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length));
+ png_uint_32 length));
#ifdef PNG_READ_bKGD_SUPPORTED
PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_cHRM_SUPPORTED
PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_gAMA_SUPPORTED
PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_hIST_SUPPORTED
PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_iCCP_SUPPORTED
extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length));
+ png_uint_32 length));
#endif /* PNG_READ_iCCP_SUPPORTED */
#ifdef PNG_READ_iTXt_SUPPORTED
PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_oFFs_SUPPORTED
PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_pCAL_SUPPORTED
PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_pHYs_SUPPORTED
PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_sBIT_SUPPORTED
PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_sCAL_SUPPORTED
PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_sPLT_SUPPORTED
extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif /* PNG_READ_sPLT_SUPPORTED */
#ifdef PNG_READ_sRGB_SUPPORTED
PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_tEXt_SUPPORTED
PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_tIME_SUPPORTED
PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_tRNS_SUPPORTED
PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
#ifdef PNG_READ_zTXt_SUPPORTED
PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
- png_uint_32 length)) PNG_PRIVATE;
+ png_uint_32 length)) PNG_PRIVATE;
#endif
PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
/* Added at libpng version 1.2.41 */
PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,
- png_uint_32 width, png_uint_32 height, int bit_depth,
- int color_type, int interlace_type, int compression_type,
- int filter_type)) PNG_PRIVATE;
+ png_uint_32 width, png_uint_32 height, int bit_depth,
+ int color_type, int interlace_type, int compression_type,
+ int filter_type)) PNG_PRIVATE;
/* Added at libpng version 1.2.41 */
PNG_EXTERN png_voidp png_calloc PNGARG((png_structp png_ptr,
- png_uint_32 size));
+ png_uint_32 size));
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
*/
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
- z_streamp source));
+ z_streamp source));
/*
Sets the destination stream as a complete copy of the source stream.
*/
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
- int level,
- int strategy));
+ int level,
+ int strategy));
/*
Dynamically update the compression level and compression strategy. The
interpretation of level and strategy is as in deflateInit2. This can be
*/
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
- int good_length,
- int max_lazy,
- int nice_length,
- int max_chain));
+ int good_length,
+ int max_lazy,
+ int nice_length,
+ int max_chain));
/*
Fine tune deflate's internal compression parameters. This should only be
used by someone who understands the algorithm used by zlib's deflate for
*/
ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
- uLong sourceLen));
+ uLong sourceLen));
/*
deflateBound() returns an upper bound on the compressed size after
deflation of sourceLen bytes. It must be called after deflateInit() or
*/
ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
- int bits,
- int value));
+ int bits,
+ int value));
/*
deflatePrime() inserts bits in the deflate output stream. The intent
is that this function is used to start off the deflate output with the bits
*/
ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
- gz_headerp head));
+ gz_headerp head));
/*
deflateSetHeader() provides gzip header information for when a gzip
stream is requested by deflateInit2(). deflateSetHeader() may be called
*/
ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
- z_streamp source));
+ z_streamp source));
/*
Sets the destination stream as a complete copy of the source stream.
*/
ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
- int windowBits));
+ int windowBits));
/*
This function is the same as inflateReset, but it also permits changing
the wrap and window size requests. The windowBits parameter is interpreted
*/
ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
- int bits,
- int value));
+ int bits,
+ int value));
/*
This function inserts bits in the inflate input stream. The intent is
that this function is used to start inflating at a bit position in the
*/
ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
- gz_headerp head));
+ gz_headerp head));
/*
inflateGetHeader() requests that gzip header information be stored in the
provided gz_header structure. inflateGetHeader() may be called after
typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
- in_func in, void FAR *in_desc,
- out_func out, void FAR *out_desc));
+ in_func in, void FAR *in_desc,
+ out_func out, void FAR *out_desc));
/*
inflateBack() does a raw inflate with a single call using a call-back
interface for input and output. This is more efficient than inflate() for
*/
ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong sourceLen));
+ const Bytef *source, uLong sourceLen));
/*
Compresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total size
*/
ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong sourceLen,
- int level));
+ const Bytef *source, uLong sourceLen,
+ int level));
/*
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
*/
ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong sourceLen));
+ const Bytef *source, uLong sourceLen));
/*
Decompresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total size
*/
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
- voidpc buf, unsigned len));
+ voidpc buf, unsigned len));
/*
Writes the given number of uncompressed bytes into the compressed file.
gzwrite returns the number of uncompressed bytes written or 0 in case of
* and the compiler's view of z_stream:
*/
ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
- const char *version, int stream_size));
+ const char *version, int stream_size));
ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
- const char *version, int stream_size));
+ const char *version, int stream_size));
ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
- int windowBits, int memLevel,
- int strategy, const char *version,
- int stream_size));
+ int windowBits, int memLevel,
+ int strategy, const char *version,
+ int stream_size));
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
- const char *version, int stream_size));
+ const char *version, int stream_size));
ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
- unsigned char FAR *window,
- const char *version,
- int stream_size));
+ unsigned char FAR *window,
+ const char *version,
+ int stream_size));
#define deflateInit(strm, level) \
deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
#define inflateInit(strm) \
EGLBoolean
eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
- EGLint *num_config)
+ 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)
+ 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)
+ EGLint *value)
{
INIT_EXPORT();
return ovr_eglGetConfigAttrib(dpy, config, attribute, value);
EGLSurface
eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativeWindowType win, const EGLint *attrib_list)
+ 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)
+ 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)
+ EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
INIT_EXPORT();
return ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
EGLBoolean
eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
- EGLint *value)
+ EGLint *value)
{
INIT_EXPORT();
return ovr_eglQuerySurface(dpy, surface, attribute, value);
EGLSurface
eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
- EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
+ EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{
INIT_EXPORT();
return ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config,
EGLBoolean
eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
- EGLint value)
+ EGLint value)
{
INIT_EXPORT();
return ovr_eglSurfaceAttrib(dpy, surface, attribute, value);
EGLContext
eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context,
- const EGLint *attrib_list)
+ const EGLint *attrib_list)
{
INIT_EXPORT();
return ovr_eglCreateContext(dpy, config, share_context, attrib_list);
}
set_driver_gl_version = dlsym(lib_handle, "set_driver_gl_version");
- if(set_driver_gl_version)
+ if (set_driver_gl_version)
set_driver_gl_version(1);
else
printf("%s\n", dlerror());
}
void
-glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
ovr_glFrustumf(left, right, bottom, top, zNear, zFar);
}
}
void
-glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
+glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
{
ovr_glOrthof(left, right, bottom, top, zNear, zFar);
}
}
void
-glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
ovr_glFrustumx(left, right, bottom, top, zNear, zFar);
}
}
void
-glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
+glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
{
ovr_glOrthox(left, right, bottom, top, zNear, zFar);
}
}
void
-glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer)
{
ovr_glTexCoordPointer(size, type, stride, pointer);
}
}
set_driver_gl_version = dlsym(lib_handle, "set_driver_gl_version");
- if(set_driver_gl_version)
+ if (set_driver_gl_version)
set_driver_gl_version(2);
else
LOGE("%s\n", dlerror());
void
glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
- GLenum dstAlpha)
+ GLenum dstAlpha)
{
ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void
glFramebufferRenderbuffer(GLenum target, GLenum attachment,
- GLenum renderbuffertarget, GLuint renderbuffer)
+ GLenum renderbuffertarget, GLuint renderbuffer)
{
ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
- renderbuffer);
+ renderbuffer);
}
void
glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
- GLuint texture, GLint level)
+ GLuint texture, GLint level)
{
ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void
glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
- GLsizei *length, GLint *size, GLenum *type, char *name)
+ 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)
+ 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)
+ GLuint *shaders)
{
ovr_glGetAttachedShaders(program, maxcount, count, shaders);
}
void
glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
void
glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
}
void
glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
- char *infolog)
+ char *infolog)
{
ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
}
void
glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
- GLint *range, GLint *precision)
+ GLint *range, GLint *precision)
{
ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
void
glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width,
- GLsizei height)
+ GLsizei height)
{
ovr_glRenderbufferStorage(target, internalformat, width, height);
}
void
glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
- const void *binary, GLsizei length)
+ const void *binary, GLsizei length)
{
ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
}
void
glShaderSource(GLuint shader, GLsizei count, const char **string,
- const GLint *length)
+ const GLint *length)
{
ovr_glShaderSource(shader, count, string, length);
}
void
glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix2fv(location, count, transpose, value);
}
void
glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix3fv(location, count, transpose, value);
}
void
glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix4fv(location, count, transpose, value);
}
void
glVertexAttribPointer(GLuint index, GLint size, GLenum type,
- GLboolean normalized, GLsizei stride, const void *pointer)
+ GLboolean normalized, GLsizei stride, const void *pointer)
{
ovr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}
void
glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
- GLenum type, const GLvoid *indices)
+ GLenum type, const GLvoid *indices)
{
ovr_glDrawRangeElements(mode, start, end, count, type, indices);
}
void
glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width,
- GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
- const GLvoid *pixels)
+ GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
+ const GLvoid *pixels)
{
ovr_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border,
- format, type, pixels);
+ format, type, pixels);
}
void
glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format,
- GLenum type, const GLvoid *pixels)
+ GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format,
+ GLenum type, const GLvoid *pixels)
{
ovr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
- depth, format, type, pixels);
+ depth, format, type, pixels);
}
void
glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
- height);
+ height);
}
void
glCompressedTexImage3D(GLenum target, GLint level, GLenum GLinternalformat,
- GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
- const GLvoid *data)
+ GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
+ const GLvoid *data)
{
ovr_glCompressedTexImage3D(target, level, GLinternalformat, width, height,
- depth, border, imageSize, data);
+ depth, border, imageSize, data);
}
void
glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
- GLenum format, GLsizei imageSize, const GLvoid *data)
+ GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLsizei imageSize, const GLvoid *data)
{
ovr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
- height, depth, format, imageSize, data);
+ height, depth, format, imageSize, data);
}
void
void
glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix2x3fv(location, count, transpose, value);
}
void
glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix3x2fv(location, count, transpose, value);
}
void
glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix2x4fv(location, count, transpose, value);
}
void
glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix4x2fv(location, count, transpose, value);
}
void
glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix3x4fv(location, count, transpose, value);
}
void
glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glUniformMatrix4x3fv(location, count, transpose, value);
}
void
glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
- GLenum filter)
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
+ GLenum filter)
{
ovr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
- mask, filter);
+ mask, filter);
}
void
glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height)
+ GLenum internalformat, GLsizei width, GLsizei height)
{
ovr_glRenderbufferStorageMultisample(target, samples, internalformat, width,
- height);
+ height);
}
void
glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture,
- GLint level, GLint layer)
+ GLint level, GLint layer)
{
ovr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
GLvoid *
glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
- GLbitfield access)
+ GLbitfield access)
{
return ovr_glMapBufferRange(target, offset, length, access);
}
void
glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset,
- GLsizeiptr size)
+ GLsizeiptr size)
{
ovr_glBindBufferRange(target, index, buffer, offset, size);
}
void
glTransformFeedbackVaryings(GLuint program, GLsizei count,
- const GLchar *const *varyings, GLenum bufferMode)
+ const GLchar *const *varyings, GLenum bufferMode)
{
ovr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}
void
glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize,
- GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
+ GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
ovr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type,
- name);
+ name);
}
void
glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride,
- const GLvoid *pointer)
+ const GLvoid *pointer)
{
ovr_glVertexAttribIPointer(index, size, type, stride, pointer);
}
void
glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset,
- GLintptr writeOffset, GLsizeiptr size)
+ GLintptr writeOffset, GLsizeiptr size)
{
ovr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
void
glGetUniformIndices(GLuint program, GLsizei uniformCount,
- const GLchar *const *uniformNames, GLuint *uniformIndices)
+ const GLchar *const *uniformNames, GLuint *uniformIndices)
{
ovr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}
void
glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
- const GLuint *uniformIndices, GLenum pname, GLint *params)
+ const GLuint *uniformIndices, GLenum pname, GLint *params)
{
ovr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}
void
glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
ovr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}
void
glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
- GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+ GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
{
ovr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
- uniformBlockName);
+ uniformBlockName);
}
void
glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
- GLuint uniformBlockBinding)
+ GLuint uniformBlockBinding)
{
ovr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void
glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
- GLsizei instanceCount)
+ GLsizei instanceCount)
{
ovr_glDrawArraysInstanced(mode, first, count, instanceCount);
}
void
glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
- const GLvoid *indices, GLsizei instanceCount)
+ const GLvoid *indices, GLsizei instanceCount)
{
ovr_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
}
void
glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
- GLint *values)
+ GLint *values)
{
ovr_glGetSynciv(sync, pname, bufSize, length, values);
}
void
glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
- GLenum *binaryFormat, GLvoid *binary)
+ GLenum *binaryFormat, GLvoid *binary)
{
ovr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
}
void
glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary,
- GLsizei length)
+ GLsizei length)
{
ovr_glProgramBinary(program, binaryFormat, binary, length);
}
void
glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments)
+ const GLenum *attachments)
{
ovr_glInvalidateFramebuffer(target, numAttachments, attachments);
}
void
glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
- const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
+ const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
- height);
+ height);
}
void
glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height)
+ GLsizei width, GLsizei height)
{
ovr_glTexStorage2D(target, levels, internalformat, width, height);
}
void
glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
- GLsizei width, GLsizei height, GLsizei depth)
+ GLsizei width, GLsizei height, GLsizei depth)
{
ovr_glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void
glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
- GLsizei bufSize, GLint *params)
+ GLsizei bufSize, GLint *params)
{
ovr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
}
/* GLES3.1 API */
GLuint
glCreateShaderProgramv(GLenum type, GLsizei count,
- const GLchar *const *strings)
+ const GLchar *const *strings)
{
return ovr_glCreateShaderProgramv(type, count, strings);
}
void
glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length,
- GLchar *infoLog)
+ GLchar *infoLog)
{
ovr_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}
void
glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname,
- GLint *params)
+ GLint *params)
{
ovr_glGetProgramInterfaceiv(program, programInterface, pname, params);
}
GLuint
glGetProgramResourceIndex( GLuint program, GLenum programInterface,
- const char *name)
+ const char *name)
{
return ovr_glGetProgramResourceIndex(program, programInterface, name);
}
void
glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index,
- GLsizei bufSize, GLsizei *length, GLchar *name)
+ GLsizei bufSize, GLsizei *length, GLchar *name)
{
ovr_glGetProgramResourceName(program, programInterface, index, bufSize, length,
- name);
+ name);
}
void
glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index,
- GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length,
- GLint *params)
+ GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length,
+ GLint *params)
{
ovr_glGetProgramResourceiv(program, programInterface, index, propCount,
- props, bufSize, length, params);
+ props, bufSize, length, params);
}
GLint
glGetProgramResourceLocation(GLuint program, GLenum programInterface,
- GLchar const *name)
+ GLchar const *name)
{
return ovr_glGetProgramResourceLocation(program, programInterface, name);
}
void
glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform1iv(program, location, count, value);
}
void
glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform2iv(program, location, count, value);
}
void
glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform3iv(program, location, count, value);
}
void
glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
- const GLint *value)
+ const GLint *value)
{
ovr_glProgramUniform4iv(program, location, count, value);
}
void
glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform1fv(program, location, count, value);
}
void
glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform2fv(program, location, count, value);
}
void
glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform3fv(program, location, count, value);
}
void
glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
- const GLfloat *value)
+ const GLfloat *value)
{
ovr_glProgramUniform4fv(program, location, count, value);
}
void
glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4fv(program, location, count, transpose, value);
}
void
glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y, GLint z,
- GLint w)
+ GLint w)
{
ovr_glProgramUniform4i(program, location, x, y, z, w);
}
void
glProgramUniform3f(GLuint program, GLint location, GLfloat x, GLfloat y,
- GLfloat z)
+ GLfloat z)
{
ovr_glProgramUniform3f(program, location, x, y, z);
}
void
glProgramUniform4f(GLuint program, GLint location, GLfloat x, GLfloat y,
- GLfloat z, GLfloat w)
+ GLfloat z, GLfloat w)
{
ovr_glProgramUniform4f(program, location, x, y, z, w);
}
void
glProgramUniform3ui(GLuint program, GLint location, GLuint x, GLuint y,
- GLuint z)
+ GLuint z)
{
ovr_glProgramUniform3ui(program, location, x, y, z);
}
void
glProgramUniform4ui(GLuint program, GLint location, GLuint x, GLuint y,
- GLuint z, GLuint w)
+ GLuint z, GLuint w)
{
ovr_glProgramUniform4ui(program, location, x, y, z, w);
}
void
glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform1uiv(program, location, count, value);
}
void
glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform2uiv(program, location, count, value);
}
void
glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform3uiv(program, location, count, value);
}
void
glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
- const GLuint *value)
+ const GLuint *value)
{
ovr_glProgramUniform4uiv(program, location, count, value);
}
void
glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}
void
glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
- GLboolean transpose, const GLfloat *value)
+ GLboolean transpose, const GLfloat *value)
{
ovr_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}
void
glBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered,
- GLint layer, GLenum access, GLenum format)
+ GLint layer, GLenum access, GLenum format)
{
ovr_glBindImageTexture (unit, texture, level, layered, layer, access, format);
}
void
glTexStorage2DMultisample (GLenum target, GLsizei samples,
- GLenum internalformat, GLsizei width, GLsizei height,
- GLboolean fixedsamplelocations)
+ GLenum internalformat, GLsizei width, GLsizei height,
+ GLboolean fixedsamplelocations)
{
ovr_glTexStorage2DMultisample (target, samples, internalformat, width, height,
- fixedsamplelocations);
+ fixedsamplelocations);
}
void
glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
- GLint *params)
+ GLint *params)
{
ovr_glGetTexLevelParameteriv (target, level, pname, params);
}
void
glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
- GLfloat *params)
+ GLfloat *params)
{
ovr_glGetTexLevelParameterfv (target, level, pname, params);
}
void
glBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset,
- GLsizei stride)
+ GLsizei stride)
{
ovr_glBindVertexBuffer (bindingindex, buffer, offset, stride);
}
void
glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type,
- GLboolean normalized, GLuint relativeoffset)
+ GLboolean normalized, GLuint relativeoffset)
{
ovr_glVertexAttribFormat (attribindex, size, type, normalized, relativeoffset);
}
void
glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type,
- GLuint relativeoffset)
+ GLuint relativeoffset)
{
ovr_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
}
}
void
-glCopyImageSubData (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)
+glCopyImageSubData (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)
{
- ovr_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+ ovr_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
+ dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void
-glDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
+glDebugMessageControl (GLenum source, GLenum type, GLenum severity,
+ GLsizei count, const GLuint *ids, GLboolean enabled)
{
ovr_glDebugMessageControl (source, type, severity, count, ids, enabled);
}
void
-glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
+glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity,
+ GLsizei length, const GLchar *buf)
{
ovr_glDebugMessageInsert(source, type, id, severity, length, buf);
}
}
GLuint
-glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
+glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources,
+ GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths,
+ GLchar *messageLog)
{
- return ovr_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+ return ovr_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities,
+ lengths, messageLog);
}
void
-glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
+glPushDebugGroup(GLenum source, GLuint id, GLsizei length,
+ const GLchar *message)
{
ovr_glPushDebugGroup(source, id, length, message);
}
}
void
-glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
+glObjectLabel(GLenum identifier, GLuint name, GLsizei length,
+ const GLchar *label)
{
ovr_glObjectLabel(identifier, name, length, label);
}
void
-glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
+glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
+ GLsizei *length, GLchar *label)
{
ovr_glGetObjectLabel(identifier, name, bufSize, length, label);
}
}
void
-glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
+glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length,
+ GLchar *label)
{
ovr_glGetObjectPtrLabel(ptr, bufSize, length, label);
}
}
void
-glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
+ GLenum dstAlpha)
{
ovr_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
}
void
-glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
+glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const void *indices, GLint basevertex)
{
ovr_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
}
void
-glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
+glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+ GLsizei count, GLenum type, const void *indices, GLint basevertex)
{
- ovr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+ ovr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices,
+ basevertex);
}
void
-glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
+glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const void *indices, GLsizei instancecount, GLint basevertex)
{
- ovr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+ ovr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
+ basevertex);
}
void
-glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture,
+ GLint level)
{
ovr_glFramebufferTexture(target, attachment, texture, level);
}
void
-glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
+glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW,
+ GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
{
ovr_glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}
return ovr_glGetGraphicsResetStatus();
}
void
-glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
+glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+ GLenum type, GLsizei bufSize, void *data)
{
ovr_glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
void
-glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
+glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize,
+ GLfloat *params)
{
ovr_glGetnUniformfv(program, location, bufSize, params);
}
}
void
-glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
+glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize,
+ GLuint *params)
{
ovr_glGetnUniformuiv(program, location, bufSize, params);
}
}
void
-glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer,
+ GLintptr offset, GLsizeiptr size)
{
ovr_glTexBufferRange(target, internalformat, buffer, offset, size);
}
void
-glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
+glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat,
+ GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
- ovr_glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+ ovr_glTexStorage3DMultisample(target, samples, internalformat, width, height,
+ depth, fixedsamplelocations);
}
void
glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
- const void *data)
+ const void *data)
{
ovr_glBufferSubData(target, offset, size, data);
}
void
glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
- GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
- const void *data)
+ GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
+ const void *data)
{
ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border,
- imageSize, data);
+ imageSize, data);
}
void
glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
- GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
- const void *data)
+ GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
+ const void *data)
{
ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
- format, imageSize, data);
+ format, imageSize, data);
}
void
glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x,
- GLint y, GLsizei width, GLsizei height, GLint border)
+ GLint y, GLsizei width, GLsizei height, GLint border)
{
ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height,
- border);
+ border);
}
void
glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLint x, GLint y, GLsizei width, GLsizei height)
+ GLint x, GLint y, GLsizei width, GLsizei height)
{
ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void
glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
- GLenum type, void *pixels)
+ GLenum type, void *pixels)
{
ovr_glReadPixels(x, y, width, height, format, type, pixels);
}
void
glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width,
- GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
+ GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
{
ovr_glTexImage2D(target, level, internalformat, width, height, border, format,
- type, pixels);
+ type, pixels);
}
void
void
glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+ GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
- type, pixels);
+ type, pixels);
}
void
projects / platform / core / uifw / coregl.git / commitdiff