Created
August 14, 2012 20:00
-
-
Save eonil/3352303 to your computer and use it in GitHub Desktop.
Generate debugging stubs with OpenGL-ES headers.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # | |
| # 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 | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // 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