Skip to content

@Eonil /Helper_EEGLDebugStub.h
Created

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Generate debugging stubs with OpenGL-ES headers.
#
# based on idea:
# http://stackoverflow.com/questions/8424397/can-i-trigger-a-breakpoint-on-opengl-errors-in-xcode-4
#
f = open ('gl.h')
deflines = []
print '#define EEGL_DEBUG_STUB_FUNC_DECORATION'
print '#define EEGL_DEBUG_STUB_EXCEPT_ERROR'
print ''
for line in f:
isGLES = line.startswith('GL_API');
isGL = line.startswith('extern void');
if isGL or isGLES:
funcReturnType = ''
funcName = ''
argssExpr = ''
if isGLES:
p1 = line.split('GL_APIENTRY')
p1a = p1[0].split(' ')
funcReturnType = p1a[1].strip(' ')
p1b = p1[1].partition(' ')[2]
funcName = p1b.partition(' ')[0]
argstr = p1b.partition(' ')[2]
p2a = argstr.partition('(')[2]
argsExpr = p2a.partition(')')[0]
if isGL:
funcexpr = line.partition(' ')[2]
funcReturnType = funcexpr.partition(' ')[0]
funcName = funcexpr.partition(' ')[2].partition(' ')[0]
argsExpr = funcexpr.partition(' ')[2].partition(' ')[2].strip(' (')
argsExpr = argsExpr.partition(';')[0].strip(' )')
args = argsExpr.split(',')
argstr = ','.join(args)
argnames = []
for arg in args:
argType = arg.rpartition(' ')[0].strip(' ')
argName = arg.rpartition(' ')[2].strip(' ')
argnames.append(argName)
callargs = ','.join(argnames)
if callargs == 'void':
callargs = ''
shouldReturn = funcReturnType != 'void'
setret = ''
if shouldReturn:
setret = funcReturnType + ' R = '
retexp = ''
if shouldReturn:
retexp = 'return R;';
substname = 'EEGLDebugStubFunc_' + funcName
print 'EEGL_DEBUG_STUB_FUNC_DECORATION'
print funcReturnType + ' ' + substname + '(' + argstr + ')'
print '{'
print '\t' + setret + funcName + '(' + callargs + ');'
print '\t' + 'EEGL_DEBUG_STUB_EXCEPT_ERROR'
print '\t' + retexp;
print '}'
defline = '#define ' + funcName + '(' + callargs + ') ' + substname + '(' + callargs + ')'
deflines.append(defline)
for defline in deflines:
print defline
// Example usage
// fixed and added some codes
//
#define EEGL_DEBUG_STUB_FUNC_DECORATION static
#define EEGL_DEBUG_STUB_EXCEPT_ERROR {HelperAssertGLError();}
static
void
HelperAssertGLError()
{
ASS ( glGetError() == 0 );
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glActiveTexture(GLenum texture)
{
glActiveTexture(texture);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glAttachShader(GLuint program, GLuint shader)
{
glAttachShader(program,shader);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
{
glBindAttribLocation(program,index,name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBindBuffer(GLenum target, GLuint buffer)
{
glBindBuffer(target,buffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBindFramebuffer(GLenum target, GLuint framebuffer)
{
glBindFramebuffer(target,framebuffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
glBindRenderbuffer(target,renderbuffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBindTexture(GLenum target, GLuint texture)
{
glBindTexture(target,texture);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
glBlendColor(red,green,blue,alpha);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBlendEquation( GLenum mode )
{
glBlendEquation(mode);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
glBlendEquationSeparate(modeRGB,modeAlpha);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
glBlendFunc(sfactor,dfactor);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
{
glBufferData(target,size,data,usage);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
{
glBufferSubData(target,offset,size,data);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLenum EEGLDebugStubFunc_glCheckFramebufferStatus(GLenum target)
{
GLenum R = glCheckFramebufferStatus(target);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glClear(GLbitfield mask)
{
glClear(mask);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
glClearColor(red,green,blue,alpha);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glClearDepthf(GLclampf depth)
{
glClearDepthf(depth);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glClearStencil(GLint s)
{
glClearStencil(s);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
glColorMask(red,green,blue,alpha);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCompileShader(GLuint shader)
{
glCompileShader(shader);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
{
glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
{
glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLuint EEGLDebugStubFunc_glCreateProgram(void)
{
GLuint R = glCreateProgram();
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLuint EEGLDebugStubFunc_glCreateShader(GLenum type)
{
GLuint R = glCreateShader(type);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glCullFace(GLenum mode)
{
glCullFace(mode);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteBuffers(GLsizei n, const GLuint* buffers)
{
glDeleteBuffers(n,buffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
{
glDeleteFramebuffers(n,framebuffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteProgram(GLuint program)
{
glDeleteProgram(program);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
glDeleteRenderbuffers(n,renderbuffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteShader(GLuint shader)
{
glDeleteShader(shader);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDeleteTextures(GLsizei n, const GLuint* textures)
{
glDeleteTextures(n,textures);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDepthFunc(GLenum func)
{
glDepthFunc(func);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDepthMask(GLboolean flag)
{
glDepthMask(flag);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDepthRangef(GLclampf zNear, GLclampf zFar)
{
glDepthRangef(zNear,zFar);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDetachShader(GLuint program, GLuint shader)
{
glDetachShader(program,shader);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDisable(GLenum cap)
{
glDisable(cap);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDisableVertexAttribArray(GLuint index)
{
glDisableVertexAttribArray(index);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
glDrawArrays(mode,first,count);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
glDrawElements(mode,count,type,indices);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glEnable(GLenum cap)
{
glEnable(cap);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glEnableVertexAttribArray(GLuint index)
{
glEnableVertexAttribArray(index);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glFinish(void)
{
glFinish();
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glFlush(void)
{
glFlush();
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
glFramebufferTexture2D(target,attachment,textarget,texture,level);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glFrontFace(GLenum mode)
{
glFrontFace(mode);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGenBuffers(GLsizei n, GLuint* buffers)
{
glGenBuffers(n,buffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGenerateMipmap(GLenum target)
{
glGenerateMipmap(target);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
{
glGenFramebuffers(n,framebuffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
glGenRenderbuffers(n,renderbuffers);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGenTextures(GLsizei n, GLuint* textures)
{
glGenTextures(n,textures);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
glGetActiveAttrib(program,index,bufsize,length,size,type,name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
glGetActiveUniform(program,index,bufsize,length,size,type,name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
glGetAttachedShaders(program,maxcount,count,shaders);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
int EEGLDebugStubFunc_glGetAttribLocation(GLuint program, const GLchar* name)
{
int R = glGetAttribLocation(program,name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetBooleanv(GLenum pname, GLboolean* params)
{
glGetBooleanv(pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
glGetBufferParameteriv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLenum EEGLDebugStubFunc_glGetError(void)
{
GLenum R = glGetError();
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetFloatv(GLenum pname, GLfloat* params)
{
glGetFloatv(pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
glGetFramebufferAttachmentParameteriv(target,attachment,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetIntegerv(GLenum pname, GLint* params)
{
glGetIntegerv(pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
glGetProgramiv(program,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
{
glGetProgramInfoLog(program,bufsize,length,infolog);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
glGetRenderbufferParameteriv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
glGetShaderiv(shader,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
{
glGetShaderInfoLog(shader,bufsize,length,infolog);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
{
glGetShaderSource(shader,bufsize,length,source);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
const GLubyte * EEGLDebugStubFunc_glGetString(GLenum name)
{
const GLubyte * R = glGetString(name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
{
glGetTexParameterfv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
{
glGetTexParameteriv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
glGetUniformfv(program,location,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetUniformiv(GLuint program, GLint location, GLint* params)
{
glGetUniformiv(program,location,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
int EEGLDebugStubFunc_glGetUniformLocation(GLuint program, const GLchar* name)
{
int R = glGetUniformLocation(program,name);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
{
glGetVertexAttribfv(index,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
{
glGetVertexAttribiv(index,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
{
glGetVertexAttribPointerv(index,pname,pointer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glHint(GLenum target, GLenum mode)
{
glHint(target,mode);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsBuffer(GLuint buffer)
{
GLboolean R = glIsBuffer(buffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsEnabled(GLenum cap)
{
GLboolean R = glIsEnabled(cap);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsFramebuffer(GLuint framebuffer)
{
GLboolean R = glIsFramebuffer(framebuffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsProgram(GLuint program)
{
GLboolean R = glIsProgram(program);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsRenderbuffer(GLuint renderbuffer)
{
GLboolean R = glIsRenderbuffer(renderbuffer);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsShader(GLuint shader)
{
GLboolean R = glIsShader(shader);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
GLboolean EEGLDebugStubFunc_glIsTexture(GLuint texture)
{
GLboolean R = glIsTexture(texture);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
return R;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glLineWidth(GLfloat width)
{
glLineWidth(width);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glLinkProgram(GLuint program)
{
glLinkProgram(program);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glPixelStorei(GLenum pname, GLint param)
{
glPixelStorei(pname,param);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glPolygonOffset(GLfloat factor, GLfloat units)
{
glPolygonOffset(factor,units);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
{
glReadPixels(x,y,width,height,format,type,pixels);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glReleaseShaderCompiler(void)
{
glReleaseShaderCompiler();
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
glRenderbufferStorage(target,internalformat,width,height);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glSampleCoverage(GLclampf value, GLboolean invert)
{
glSampleCoverage(value,invert);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
glScissor(x,y,width,height);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
{
glShaderBinary(n,shaders,binaryformat,binary,length);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length)
{
glShaderSource(shader,count,string,length);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
glStencilFunc(func,ref,mask);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
glStencilFuncSeparate(face,func,ref,mask);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilMask(GLuint mask)
{
glStencilMask(mask);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilMaskSeparate(GLenum face, GLuint mask)
{
glStencilMaskSeparate(face,mask);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
glStencilOp(fail,zfail,zpass);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
glStencilOpSeparate(face,fail,zfail,zpass);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
glTexParameterf(target,pname,param);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
{
glTexParameterfv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexParameteri(GLenum target, GLenum pname, GLint param)
{
glTexParameteri(target,pname,param);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
{
glTexParameteriv(target,pname,params);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
{
glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform1f(GLint location, GLfloat x)
{
glUniform1f(location,x);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
{
glUniform1fv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform1i(GLint location, GLint x)
{
glUniform1i(location,x);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform1iv(GLint location, GLsizei count, const GLint* v)
{
glUniform1iv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform2f(GLint location, GLfloat x, GLfloat y)
{
glUniform2f(location,x,y);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
{
glUniform2fv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform2i(GLint location, GLint x, GLint y)
{
glUniform2i(location,x,y);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform2iv(GLint location, GLsizei count, const GLint* v)
{
glUniform2iv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
glUniform3f(location,x,y,z);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
{
glUniform3fv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform3i(GLint location, GLint x, GLint y, GLint z)
{
glUniform3i(location,x,y,z);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform3iv(GLint location, GLsizei count, const GLint* v)
{
glUniform3iv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
glUniform4f(location,x,y,z,w);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
{
glUniform4fv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
{
glUniform4i(location,x,y,z,w);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniform4iv(GLint location, GLsizei count, const GLint* v)
{
glUniform4iv(location,count,v);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
glUniformMatrix2fv(location,count,transpose,value);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
glUniformMatrix3fv(location,count,transpose,value);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
glUniformMatrix4fv(location,count,transpose,value);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glUseProgram(GLuint program)
{
glUseProgram(program);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glValidateProgram(GLuint program)
{
glValidateProgram(program);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib1f(GLuint indx, GLfloat x)
{
glVertexAttrib1f(indx,x);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
{
glVertexAttrib1fv(indx,values);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
{
glVertexAttrib2f(indx,x,y);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
{
glVertexAttrib2fv(indx,values);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
{
glVertexAttrib3f(indx,x,y,z);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
{
glVertexAttrib3fv(indx,values);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
glVertexAttrib4f(indx,x,y,z,w);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
{
glVertexAttrib4fv(indx,values);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
{
glVertexAttribPointer(indx,size,type,normalized,stride,ptr);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
EEGL_DEBUG_STUB_FUNC_DECORATION
void EEGLDebugStubFunc_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
glViewport(x,y,width,height);
EEGL_DEBUG_STUB_EXCEPT_ERROR;
}
#define glActiveTexture(texture) EEGLDebugStubFunc_glActiveTexture(texture)
#define glAttachShader(program,shader) EEGLDebugStubFunc_glAttachShader(program,shader)
#define glBindAttribLocation(program,index,name) EEGLDebugStubFunc_glBindAttribLocation(program,index,name)
#define glBindBuffer(target,buffer) EEGLDebugStubFunc_glBindBuffer(target,buffer)
#define glBindFramebuffer(target,framebuffer) EEGLDebugStubFunc_glBindFramebuffer(target,framebuffer)
#define glBindRenderbuffer(target,renderbuffer) EEGLDebugStubFunc_glBindRenderbuffer(target,renderbuffer)
#define glBindTexture(target,texture) EEGLDebugStubFunc_glBindTexture(target,texture)
#define glBlendColor(red,green,blue,alpha) EEGLDebugStubFunc_glBlendColor(red,green,blue,alpha)
#define glBlendEquation() EEGLDebugStubFunc_glBlendEquation()
#define glBlendEquationSeparate(modeRGB,modeAlpha) EEGLDebugStubFunc_glBlendEquationSeparate(modeRGB,modeAlpha)
#define glBlendFunc(sfactor,dfactor) EEGLDebugStubFunc_glBlendFunc(sfactor,dfactor)
#define glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha) EEGLDebugStubFunc_glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha)
#define glBufferData(target,size,data,usage) EEGLDebugStubFunc_glBufferData(target,size,data,usage)
#define glBufferSubData(target,offset,size,data) EEGLDebugStubFunc_glBufferSubData(target,offset,size,data)
#define glCheckFramebufferStatus(target) EEGLDebugStubFunc_glCheckFramebufferStatus(target)
#define glClear(mask) EEGLDebugStubFunc_glClear(mask)
#define glClearColor(red,green,blue,alpha) EEGLDebugStubFunc_glClearColor(red,green,blue,alpha)
#define glClearDepthf(depth) EEGLDebugStubFunc_glClearDepthf(depth)
#define glClearStencil(s) EEGLDebugStubFunc_glClearStencil(s)
#define glColorMask(red,green,blue,alpha) EEGLDebugStubFunc_glColorMask(red,green,blue,alpha)
#define glCompileShader(shader) EEGLDebugStubFunc_glCompileShader(shader)
#define glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data) EEGLDebugStubFunc_glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data)
#define glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data) EEGLDebugStubFunc_glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data)
#define glCopyTexImage2D(target,level,internalformat,x,y,width,height,border) EEGLDebugStubFunc_glCopyTexImage2D(target,level,internalformat,x,y,width,height,border)
#define glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height) EEGLDebugStubFunc_glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height)
#define glCreateProgram() EEGLDebugStubFunc_glCreateProgram()
#define glCreateShader(type) EEGLDebugStubFunc_glCreateShader(type)
#define glCullFace(mode) EEGLDebugStubFunc_glCullFace(mode)
#define glDeleteBuffers(n,buffers) EEGLDebugStubFunc_glDeleteBuffers(n,buffers)
#define glDeleteFramebuffers(n,framebuffers) EEGLDebugStubFunc_glDeleteFramebuffers(n,framebuffers)
#define glDeleteProgram(program) EEGLDebugStubFunc_glDeleteProgram(program)
#define glDeleteRenderbuffers(n,renderbuffers) EEGLDebugStubFunc_glDeleteRenderbuffers(n,renderbuffers)
#define glDeleteShader(shader) EEGLDebugStubFunc_glDeleteShader(shader)
#define glDeleteTextures(n,textures) EEGLDebugStubFunc_glDeleteTextures(n,textures)
#define glDepthFunc(func) EEGLDebugStubFunc_glDepthFunc(func)
#define glDepthMask(flag) EEGLDebugStubFunc_glDepthMask(flag)
#define glDepthRangef(zNear,zFar) EEGLDebugStubFunc_glDepthRangef(zNear,zFar)
#define glDetachShader(program,shader) EEGLDebugStubFunc_glDetachShader(program,shader)
#define glDisable(cap) EEGLDebugStubFunc_glDisable(cap)
#define glDisableVertexAttribArray(index) EEGLDebugStubFunc_glDisableVertexAttribArray(index)
#define glDrawArrays(mode,first,count) EEGLDebugStubFunc_glDrawArrays(mode,first,count)
#define glDrawElements(mode,count,type,indices) EEGLDebugStubFunc_glDrawElements(mode,count,type,indices)
#define glEnable(cap) EEGLDebugStubFunc_glEnable(cap)
#define glEnableVertexAttribArray(index) EEGLDebugStubFunc_glEnableVertexAttribArray(index)
#define glFinish() EEGLDebugStubFunc_glFinish()
#define glFlush() EEGLDebugStubFunc_glFlush()
#define glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer) EEGLDebugStubFunc_glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer)
#define glFramebufferTexture2D(target,attachment,textarget,texture,level) EEGLDebugStubFunc_glFramebufferTexture2D(target,attachment,textarget,texture,level)
#define glFrontFace(mode) EEGLDebugStubFunc_glFrontFace(mode)
#define glGenBuffers(n,buffers) EEGLDebugStubFunc_glGenBuffers(n,buffers)
#define glGenerateMipmap(target) EEGLDebugStubFunc_glGenerateMipmap(target)
#define glGenFramebuffers(n,framebuffers) EEGLDebugStubFunc_glGenFramebuffers(n,framebuffers)
#define glGenRenderbuffers(n,renderbuffers) EEGLDebugStubFunc_glGenRenderbuffers(n,renderbuffers)
#define glGenTextures(n,textures) EEGLDebugStubFunc_glGenTextures(n,textures)
#define glGetActiveAttrib(program,index,bufsize,length,size,type,name) EEGLDebugStubFunc_glGetActiveAttrib(program,index,bufsize,length,size,type,name)
#define glGetActiveUniform(program,index,bufsize,length,size,type,name) EEGLDebugStubFunc_glGetActiveUniform(program,index,bufsize,length,size,type,name)
#define glGetAttachedShaders(program,maxcount,count,shaders) EEGLDebugStubFunc_glGetAttachedShaders(program,maxcount,count,shaders)
#define glGetAttribLocation(program,name) EEGLDebugStubFunc_glGetAttribLocation(program,name)
#define glGetBooleanv(pname,params) EEGLDebugStubFunc_glGetBooleanv(pname,params)
#define glGetBufferParameteriv(target,pname,params) EEGLDebugStubFunc_glGetBufferParameteriv(target,pname,params)
#define glGetError() EEGLDebugStubFunc_glGetError()
#define glGetFloatv(pname,params) EEGLDebugStubFunc_glGetFloatv(pname,params)
#define glGetFramebufferAttachmentParameteriv(target,attachment,pname,params) EEGLDebugStubFunc_glGetFramebufferAttachmentParameteriv(target,attachment,pname,params)
#define glGetIntegerv(pname,params) EEGLDebugStubFunc_glGetIntegerv(pname,params)
#define glGetProgramiv(program,pname,params) EEGLDebugStubFunc_glGetProgramiv(program,pname,params)
#define glGetProgramInfoLog(program,bufsize,length,infolog) EEGLDebugStubFunc_glGetProgramInfoLog(program,bufsize,length,infolog)
#define glGetRenderbufferParameteriv(target,pname,params) EEGLDebugStubFunc_glGetRenderbufferParameteriv(target,pname,params)
#define glGetShaderiv(shader,pname,params) EEGLDebugStubFunc_glGetShaderiv(shader,pname,params)
#define glGetShaderInfoLog(shader,bufsize,length,infolog) EEGLDebugStubFunc_glGetShaderInfoLog(shader,bufsize,length,infolog)
#define glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision) EEGLDebugStubFunc_glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision)
#define glGetShaderSource(shader,bufsize,length,source) EEGLDebugStubFunc_glGetShaderSource(shader,bufsize,length,source)
#define glGetString(name) EEGLDebugStubFunc_glGetString(name)
#define glGetTexParameterfv(target,pname,params) EEGLDebugStubFunc_glGetTexParameterfv(target,pname,params)
#define glGetTexParameteriv(target,pname,params) EEGLDebugStubFunc_glGetTexParameteriv(target,pname,params)
#define glGetUniformfv(program,location,params) EEGLDebugStubFunc_glGetUniformfv(program,location,params)
#define glGetUniformiv(program,location,params) EEGLDebugStubFunc_glGetUniformiv(program,location,params)
#define glGetUniformLocation(program,name) EEGLDebugStubFunc_glGetUniformLocation(program,name)
#define glGetVertexAttribfv(index,pname,params) EEGLDebugStubFunc_glGetVertexAttribfv(index,pname,params)
#define glGetVertexAttribiv(index,pname,params) EEGLDebugStubFunc_glGetVertexAttribiv(index,pname,params)
#define glGetVertexAttribPointerv(index,pname,pointer) EEGLDebugStubFunc_glGetVertexAttribPointerv(index,pname,pointer)
#define glHint(target,mode) EEGLDebugStubFunc_glHint(target,mode)
#define glIsBuffer(buffer) EEGLDebugStubFunc_glIsBuffer(buffer)
#define glIsEnabled(cap) EEGLDebugStubFunc_glIsEnabled(cap)
#define glIsFramebuffer(framebuffer) EEGLDebugStubFunc_glIsFramebuffer(framebuffer)
#define glIsProgram(program) EEGLDebugStubFunc_glIsProgram(program)
#define glIsRenderbuffer(renderbuffer) EEGLDebugStubFunc_glIsRenderbuffer(renderbuffer)
#define glIsShader(shader) EEGLDebugStubFunc_glIsShader(shader)
#define glIsTexture(texture) EEGLDebugStubFunc_glIsTexture(texture)
#define glLineWidth(width) EEGLDebugStubFunc_glLineWidth(width)
#define glLinkProgram(program) EEGLDebugStubFunc_glLinkProgram(program)
#define glPixelStorei(pname,param) EEGLDebugStubFunc_glPixelStorei(pname,param)
#define glPolygonOffset(factor,units) EEGLDebugStubFunc_glPolygonOffset(factor,units)
#define glReadPixels(x,y,width,height,format,type,pixels) EEGLDebugStubFunc_glReadPixels(x,y,width,height,format,type,pixels)
#define glReleaseShaderCompiler() EEGLDebugStubFunc_glReleaseShaderCompiler()
#define glRenderbufferStorage(target,internalformat,width,height) EEGLDebugStubFunc_glRenderbufferStorage(target,internalformat,width,height)
#define glSampleCoverage(value,invert) EEGLDebugStubFunc_glSampleCoverage(value,invert)
#define glScissor(x,y,width,height) EEGLDebugStubFunc_glScissor(x,y,width,height)
#define glShaderBinary(n,shaders,binaryformat,binary,length) EEGLDebugStubFunc_glShaderBinary(n,shaders,binaryformat,binary,length)
#define glShaderSource(shader,count,string,length) EEGLDebugStubFunc_glShaderSource(shader,count,string,length)
#define glStencilFunc(func,ref,mask) EEGLDebugStubFunc_glStencilFunc(func,ref,mask)
#define glStencilFuncSeparate(face,func,ref,mask) EEGLDebugStubFunc_glStencilFuncSeparate(face,func,ref,mask)
#define glStencilMask(mask) EEGLDebugStubFunc_glStencilMask(mask)
#define glStencilMaskSeparate(face,mask) EEGLDebugStubFunc_glStencilMaskSeparate(face,mask)
#define glStencilOp(fail,zfail,zpass) EEGLDebugStubFunc_glStencilOp(fail,zfail,zpass)
#define glStencilOpSeparate(face,fail,zfail,zpass) EEGLDebugStubFunc_glStencilOpSeparate(face,fail,zfail,zpass)
#define glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels) EEGLDebugStubFunc_glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels)
#define glTexParameterf(target,pname,param) EEGLDebugStubFunc_glTexParameterf(target,pname,param)
#define glTexParameterfv(target,pname,params) EEGLDebugStubFunc_glTexParameterfv(target,pname,params)
#define glTexParameteri(target,pname,param) EEGLDebugStubFunc_glTexParameteri(target,pname,param)
#define glTexParameteriv(target,pname,params) EEGLDebugStubFunc_glTexParameteriv(target,pname,params)
#define glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels) EEGLDebugStubFunc_glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels)
#define glUniform1f(location,x) EEGLDebugStubFunc_glUniform1f(location,x)
#define glUniform1fv(location,count,v) EEGLDebugStubFunc_glUniform1fv(location,count,v)
#define glUniform1i(location,x) EEGLDebugStubFunc_glUniform1i(location,x)
#define glUniform1iv(location,count,v) EEGLDebugStubFunc_glUniform1iv(location,count,v)
#define glUniform2f(location,x,y) EEGLDebugStubFunc_glUniform2f(location,x,y)
#define glUniform2fv(location,count,v) EEGLDebugStubFunc_glUniform2fv(location,count,v)
#define glUniform2i(location,x,y) EEGLDebugStubFunc_glUniform2i(location,x,y)
#define glUniform2iv(location,count,v) EEGLDebugStubFunc_glUniform2iv(location,count,v)
#define glUniform3f(location,x,y,z) EEGLDebugStubFunc_glUniform3f(location,x,y,z)
#define glUniform3fv(location,count,v) EEGLDebugStubFunc_glUniform3fv(location,count,v)
#define glUniform3i(location,x,y,z) EEGLDebugStubFunc_glUniform3i(location,x,y,z)
#define glUniform3iv(location,count,v) EEGLDebugStubFunc_glUniform3iv(location,count,v)
#define glUniform4f(location,x,y,z,w) EEGLDebugStubFunc_glUniform4f(location,x,y,z,w)
#define glUniform4fv(location,count,v) EEGLDebugStubFunc_glUniform4fv(location,count,v)
#define glUniform4i(location,x,y,z,w) EEGLDebugStubFunc_glUniform4i(location,x,y,z,w)
#define glUniform4iv(location,count,v) EEGLDebugStubFunc_glUniform4iv(location,count,v)
#define glUniformMatrix2fv(location,count,transpose,value) EEGLDebugStubFunc_glUniformMatrix2fv(location,count,transpose,value)
#define glUniformMatrix3fv(location,count,transpose,value) EEGLDebugStubFunc_glUniformMatrix3fv(location,count,transpose,value)
#define glUniformMatrix4fv(location,count,transpose,value) EEGLDebugStubFunc_glUniformMatrix4fv(location,count,transpose,value)
#define glUseProgram(program) EEGLDebugStubFunc_glUseProgram(program)
#define glValidateProgram(program) EEGLDebugStubFunc_glValidateProgram(program)
#define glVertexAttrib1f(indx,x) EEGLDebugStubFunc_glVertexAttrib1f(indx,x)
#define glVertexAttrib1fv(indx,values) EEGLDebugStubFunc_glVertexAttrib1fv(indx,values)
#define glVertexAttrib2f(indx,x,y) EEGLDebugStubFunc_glVertexAttrib2f(indx,x,y)
#define glVertexAttrib2fv(indx,values) EEGLDebugStubFunc_glVertexAttrib2fv(indx,values)
#define glVertexAttrib3f(indx,x,y,z) EEGLDebugStubFunc_glVertexAttrib3f(indx,x,y,z)
#define glVertexAttrib3fv(indx,values) EEGLDebugStubFunc_glVertexAttrib3fv(indx,values)
#define glVertexAttrib4f(indx,x,y,z,w) EEGLDebugStubFunc_glVertexAttrib4f(indx,x,y,z,w)
#define glVertexAttrib4fv(indx,values) EEGLDebugStubFunc_glVertexAttrib4fv(indx,values)
#define glVertexAttribPointer(indx,size,type,normalized,stride,ptr) EEGLDebugStubFunc_glVertexAttribPointer(indx,size,type,normalized,stride,ptr)
#define glViewport(x,y,width,height) EEGLDebugStubFunc_glViewport(x,y,width,height)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.