diff options
Diffstat (limited to 'opengl/libs/GLES2_dbg/src/api.cpp')
| -rw-r--r-- | opengl/libs/GLES2_dbg/src/api.cpp | 3653 |
1 files changed, 3653 insertions, 0 deletions
diff --git a/opengl/libs/GLES2_dbg/src/api.cpp b/opengl/libs/GLES2_dbg/src/api.cpp new file mode 100644 index 0000000..7094ca7 --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/api.cpp @@ -0,0 +1,3653 @@ +/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_api_cpp.py + +#include "src/header.h" +#include "src/api.h" + +template<typename T> static int ToInt(const T & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (int &)t; } +template<typename T> static T FromInt(const int & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (T &)t; } + +void Debug_glActiveTexture(GLenum texture) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum texture; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glActiveTexture(texture); + return 0; + } + } caller; + caller.texture = texture; + + msg.set_arg0(texture); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glActiveTexture); +} + +void Debug_glAttachShader(GLuint program, GLuint shader) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLuint shader; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glAttachShader(program, shader); + return 0; + } + } caller; + caller.program = program; + caller.shader = shader; + + msg.set_arg0(program); + msg.set_arg1(shader); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glAttachShader); +} + +void Debug_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLuint index; + const GLchar* name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBindAttribLocation(program, index, name); + return 0; + } + } caller; + caller.program = program; + caller.index = index; + caller.name = name; + + msg.set_arg0(program); + msg.set_arg1(index); + msg.set_arg2(ToInt(name)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(name), strlen(name) * sizeof(GLchar)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBindAttribLocation); +} + +void Debug_glBindBuffer(GLenum target, GLuint buffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLuint buffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBindBuffer(target, buffer); + getDbgContextThreadSpecific()->glBindBuffer(target, buffer); + return 0; + } + } caller; + caller.target = target; + caller.buffer = buffer; + + msg.set_arg0(target); + msg.set_arg1(buffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBindBuffer); +} + +void Debug_glBindFramebuffer(GLenum target, GLuint framebuffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLuint framebuffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBindFramebuffer(target, framebuffer); + return 0; + } + } caller; + caller.target = target; + caller.framebuffer = framebuffer; + + msg.set_arg0(target); + msg.set_arg1(framebuffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBindFramebuffer); +} + +void Debug_glBindRenderbuffer(GLenum target, GLuint renderbuffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLuint renderbuffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBindRenderbuffer(target, renderbuffer); + return 0; + } + } caller; + caller.target = target; + caller.renderbuffer = renderbuffer; + + msg.set_arg0(target); + msg.set_arg1(renderbuffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBindRenderbuffer); +} + +void Debug_glBindTexture(GLenum target, GLuint texture) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLuint texture; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBindTexture(target, texture); + return 0; + } + } caller; + caller.target = target; + caller.texture = texture; + + msg.set_arg0(target); + msg.set_arg1(texture); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBindTexture); +} + +void Debug_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLclampf red; + GLclampf green; + GLclampf blue; + GLclampf alpha; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBlendColor(red, green, blue, alpha); + return 0; + } + } caller; + caller.red = red; + caller.green = green; + caller.blue = blue; + caller.alpha = alpha; + + msg.set_arg0(ToInt(red)); + msg.set_arg1(ToInt(green)); + msg.set_arg2(ToInt(blue)); + msg.set_arg3(ToInt(alpha)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBlendColor); +} + +void Debug_glBlendEquation( GLenum mode ) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum mode; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBlendEquation(mode); + return 0; + } + } caller; + caller.mode = mode; + + msg.set_arg0(mode); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBlendEquation); +} + +void Debug_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum modeRGB; + GLenum modeAlpha; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBlendEquationSeparate(modeRGB, modeAlpha); + return 0; + } + } caller; + caller.modeRGB = modeRGB; + caller.modeAlpha = modeAlpha; + + msg.set_arg0(modeRGB); + msg.set_arg1(modeAlpha); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBlendEquationSeparate); +} + +void Debug_glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum sfactor; + GLenum dfactor; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBlendFunc(sfactor, dfactor); + return 0; + } + } caller; + caller.sfactor = sfactor; + caller.dfactor = dfactor; + + msg.set_arg0(sfactor); + msg.set_arg1(dfactor); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBlendFunc); +} + +void Debug_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum srcRGB; + GLenum dstRGB; + GLenum srcAlpha; + GLenum dstAlpha; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + return 0; + } + } caller; + caller.srcRGB = srcRGB; + caller.dstRGB = dstRGB; + caller.srcAlpha = srcAlpha; + caller.dstAlpha = dstAlpha; + + msg.set_arg0(srcRGB); + msg.set_arg1(dstRGB); + msg.set_arg2(srcAlpha); + msg.set_arg3(dstAlpha); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBlendFuncSeparate); +} + +void Debug_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLsizeiptr size; + const GLvoid* data; + GLenum usage; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBufferData(target, size, data, usage); + getDbgContextThreadSpecific()->glBufferData(target, size, data, usage); + return 0; + } + } caller; + caller.target = target; + caller.size = size; + caller.data = data; + caller.usage = usage; + + msg.set_arg0(target); + msg.set_arg1(size); + msg.set_arg2(ToInt(data)); + msg.set_arg3(usage); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(data), size * sizeof(char)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBufferData); +} + +void Debug_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLintptr offset; + GLsizeiptr size; + const GLvoid* data; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glBufferSubData(target, offset, size, data); + getDbgContextThreadSpecific()->glBufferSubData(target, offset, size, data); + return 0; + } + } caller; + caller.target = target; + caller.offset = offset; + caller.size = size; + caller.data = data; + + msg.set_arg0(target); + msg.set_arg1(offset); + msg.set_arg2(size); + msg.set_arg3(ToInt(data)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(data), size * sizeof(char)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glBufferSubData); +} + +GLenum Debug_glCheckFramebufferStatus(GLenum target) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glCheckFramebufferStatus(target)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.target = target; + + msg.set_arg0(target); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCheckFramebufferStatus); + return reinterpret_cast<GLenum>(ret); +} + +void Debug_glClear(GLbitfield mask) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLbitfield mask; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glClear(mask); + return 0; + } + } caller; + caller.mask = mask; + + msg.set_arg0(mask); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glClear); +} + +void Debug_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLclampf red; + GLclampf green; + GLclampf blue; + GLclampf alpha; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glClearColor(red, green, blue, alpha); + return 0; + } + } caller; + caller.red = red; + caller.green = green; + caller.blue = blue; + caller.alpha = alpha; + + msg.set_arg0(ToInt(red)); + msg.set_arg1(ToInt(green)); + msg.set_arg2(ToInt(blue)); + msg.set_arg3(ToInt(alpha)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glClearColor); +} + +void Debug_glClearDepthf(GLclampf depth) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLclampf depth; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glClearDepthf(depth); + return 0; + } + } caller; + caller.depth = depth; + + msg.set_arg0(ToInt(depth)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glClearDepthf); +} + +void Debug_glClearStencil(GLint s) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint s; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glClearStencil(s); + return 0; + } + } caller; + caller.s = s; + + msg.set_arg0(s); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glClearStencil); +} + +void Debug_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLboolean red; + GLboolean green; + GLboolean blue; + GLboolean alpha; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glColorMask(red, green, blue, alpha); + return 0; + } + } caller; + caller.red = red; + caller.green = green; + caller.blue = blue; + caller.alpha = alpha; + + msg.set_arg0(red); + msg.set_arg1(green); + msg.set_arg2(blue); + msg.set_arg3(alpha); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glColorMask); +} + +void Debug_glCompileShader(GLuint shader) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCompileShader(shader); + return 0; + } + } caller; + caller.shader = shader; + + msg.set_arg0(shader); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCompileShader); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLenum internalformat; + GLsizei width; + GLsizei height; + GLint border; + GLsizei imageSize; + const GLvoid* data; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); + return 0; + } + } caller; + caller.target = target; + caller.level = level; + caller.internalformat = internalformat; + caller.width = width; + caller.height = height; + caller.border = border; + caller.imageSize = imageSize; + caller.data = data; + + msg.set_arg0(target); + msg.set_arg1(level); + msg.set_arg2(internalformat); + msg.set_arg3(width); + msg.set_arg4(height); + msg.set_arg5(border); + msg.set_arg6(imageSize); + msg.set_arg7(ToInt(data)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCompressedTexImage2D); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLint xoffset; + GLint yoffset; + GLsizei width; + GLsizei height; + GLenum format; + GLsizei imageSize; + const GLvoid* data; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); + return 0; + } + } caller; + caller.target = target; + caller.level = level; + caller.xoffset = xoffset; + caller.yoffset = yoffset; + caller.width = width; + caller.height = height; + caller.format = format; + caller.imageSize = imageSize; + caller.data = data; + + msg.set_arg0(target); + msg.set_arg1(level); + msg.set_arg2(xoffset); + msg.set_arg3(yoffset); + msg.set_arg4(width); + msg.set_arg5(height); + msg.set_arg6(format); + msg.set_arg7(imageSize); + msg.set_arg8(ToInt(data)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCompressedTexSubImage2D); +} + +void Debug_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLenum internalformat; + GLint x; + GLint y; + GLsizei width; + GLsizei height; + GLint border; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); + return 0; + } + } caller; + caller.target = target; + caller.level = level; + caller.internalformat = internalformat; + caller.x = x; + caller.y = y; + caller.width = width; + caller.height = height; + caller.border = border; + + msg.set_arg0(target); + msg.set_arg1(level); + msg.set_arg2(internalformat); + msg.set_arg3(x); + msg.set_arg4(y); + msg.set_arg5(width); + msg.set_arg6(height); + msg.set_arg7(border); + + EXTEND_Debug_glCopyTexImage2D; + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCopyTexImage2D); +} + +void Debug_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLint xoffset; + GLint yoffset; + GLint x; + GLint y; + GLsizei width; + GLsizei height; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + return 0; + } + } caller; + caller.target = target; + caller.level = level; + caller.xoffset = xoffset; + caller.yoffset = yoffset; + caller.x = x; + caller.y = y; + caller.width = width; + caller.height = height; + + msg.set_arg0(target); + msg.set_arg1(level); + msg.set_arg2(xoffset); + msg.set_arg3(yoffset); + msg.set_arg4(x); + msg.set_arg5(y); + msg.set_arg6(width); + msg.set_arg7(height); + + EXTEND_Debug_glCopyTexSubImage2D; + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCopyTexSubImage2D); +} + +GLuint Debug_glCreateProgram(void) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glCreateProgram()); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCreateProgram); + return reinterpret_cast<GLuint>(ret); +} + +GLuint Debug_glCreateShader(GLenum type) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum type; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glCreateShader(type)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.type = type; + + msg.set_arg0(type); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCreateShader); + return reinterpret_cast<GLuint>(ret); +} + +void Debug_glCullFace(GLenum mode) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum mode; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glCullFace(mode); + return 0; + } + } caller; + caller.mode = mode; + + msg.set_arg0(mode); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glCullFace); +} + +void Debug_glDeleteBuffers(GLsizei n, const GLuint* buffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + const GLuint* buffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteBuffers(n, buffers); + getDbgContextThreadSpecific()->glDeleteBuffers(n, buffers); + return 0; + } + } caller; + caller.n = n; + caller.buffers = buffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(buffers)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(buffers), n * sizeof(GLuint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteBuffers); +} + +void Debug_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + const GLuint* framebuffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteFramebuffers(n, framebuffers); + return 0; + } + } caller; + caller.n = n; + caller.framebuffers = framebuffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(framebuffers)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(framebuffers), n * sizeof(GLuint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteFramebuffers); +} + +void Debug_glDeleteProgram(GLuint program) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteProgram(program); + return 0; + } + } caller; + caller.program = program; + + msg.set_arg0(program); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteProgram); +} + +void Debug_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + const GLuint* renderbuffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteRenderbuffers(n, renderbuffers); + return 0; + } + } caller; + caller.n = n; + caller.renderbuffers = renderbuffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(renderbuffers)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(renderbuffers), n * sizeof(GLuint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteRenderbuffers); +} + +void Debug_glDeleteShader(GLuint shader) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteShader(shader); + return 0; + } + } caller; + caller.shader = shader; + + msg.set_arg0(shader); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteShader); +} + +void Debug_glDeleteTextures(GLsizei n, const GLuint* textures) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + const GLuint* textures; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDeleteTextures(n, textures); + return 0; + } + } caller; + caller.n = n; + caller.textures = textures; + + msg.set_arg0(n); + msg.set_arg1(ToInt(textures)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(textures), n * sizeof(GLuint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDeleteTextures); +} + +void Debug_glDepthFunc(GLenum func) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum func; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDepthFunc(func); + return 0; + } + } caller; + caller.func = func; + + msg.set_arg0(func); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDepthFunc); +} + +void Debug_glDepthMask(GLboolean flag) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLboolean flag; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDepthMask(flag); + return 0; + } + } caller; + caller.flag = flag; + + msg.set_arg0(flag); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDepthMask); +} + +void Debug_glDepthRangef(GLclampf zNear, GLclampf zFar) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLclampf zNear; + GLclampf zFar; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDepthRangef(zNear, zFar); + return 0; + } + } caller; + caller.zNear = zNear; + caller.zFar = zFar; + + msg.set_arg0(ToInt(zNear)); + msg.set_arg1(ToInt(zFar)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDepthRangef); +} + +void Debug_glDetachShader(GLuint program, GLuint shader) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLuint shader; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDetachShader(program, shader); + return 0; + } + } caller; + caller.program = program; + caller.shader = shader; + + msg.set_arg0(program); + msg.set_arg1(shader); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDetachShader); +} + +void Debug_glDisable(GLenum cap) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum cap; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDisable(cap); + return 0; + } + } caller; + caller.cap = cap; + + msg.set_arg0(cap); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDisable); +} + +void Debug_glDisableVertexAttribArray(GLuint index) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint index; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glDisableVertexAttribArray(index); + getDbgContextThreadSpecific()->glDisableVertexAttribArray(index); + return 0; + } + } caller; + caller.index = index; + + msg.set_arg0(index); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glDisableVertexAttribArray); +} + +void Debug_glEnable(GLenum cap) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum cap; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glEnable(cap); + return 0; + } + } caller; + caller.cap = cap; + + msg.set_arg0(cap); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glEnable); +} + +void Debug_glEnableVertexAttribArray(GLuint index) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint index; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glEnableVertexAttribArray(index); + getDbgContextThreadSpecific()->glEnableVertexAttribArray(index); + return 0; + } + } caller; + caller.index = index; + + msg.set_arg0(index); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glEnableVertexAttribArray); +} + +void Debug_glFinish(void) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glFinish(); + return 0; + } + } caller; + + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glFinish); +} + +void Debug_glFlush(void) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glFlush(); + return 0; + } + } caller; + + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glFlush); +} + +void Debug_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum attachment; + GLenum renderbuffertarget; + GLuint renderbuffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); + return 0; + } + } caller; + caller.target = target; + caller.attachment = attachment; + caller.renderbuffertarget = renderbuffertarget; + caller.renderbuffer = renderbuffer; + + msg.set_arg0(target); + msg.set_arg1(attachment); + msg.set_arg2(renderbuffertarget); + msg.set_arg3(renderbuffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glFramebufferRenderbuffer); +} + +void Debug_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum attachment; + GLenum textarget; + GLuint texture; + GLint level; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glFramebufferTexture2D(target, attachment, textarget, texture, level); + return 0; + } + } caller; + caller.target = target; + caller.attachment = attachment; + caller.textarget = textarget; + caller.texture = texture; + caller.level = level; + + msg.set_arg0(target); + msg.set_arg1(attachment); + msg.set_arg2(textarget); + msg.set_arg3(texture); + msg.set_arg4(level); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glFramebufferTexture2D); +} + +void Debug_glFrontFace(GLenum mode) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum mode; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glFrontFace(mode); + return 0; + } + } caller; + caller.mode = mode; + + msg.set_arg0(mode); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glFrontFace); +} + +void Debug_glGenBuffers(GLsizei n, GLuint* buffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + GLuint* buffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGenBuffers(n, buffers); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(buffers), n * sizeof(GLuint)); + return 0; + } + } caller; + caller.n = n; + caller.buffers = buffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(buffers)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGenBuffers); +} + +void Debug_glGenerateMipmap(GLenum target) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGenerateMipmap(target); + return 0; + } + } caller; + caller.target = target; + + msg.set_arg0(target); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGenerateMipmap); +} + +void Debug_glGenFramebuffers(GLsizei n, GLuint* framebuffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + GLuint* framebuffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGenFramebuffers(n, framebuffers); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(framebuffers), n * sizeof(GLuint)); + return 0; + } + } caller; + caller.n = n; + caller.framebuffers = framebuffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(framebuffers)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGenFramebuffers); +} + +void Debug_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + GLuint* renderbuffers; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGenRenderbuffers(n, renderbuffers); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(renderbuffers), n * sizeof(GLuint)); + return 0; + } + } caller; + caller.n = n; + caller.renderbuffers = renderbuffers; + + msg.set_arg0(n); + msg.set_arg1(ToInt(renderbuffers)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGenRenderbuffers); +} + +void Debug_glGenTextures(GLsizei n, GLuint* textures) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + GLuint* textures; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGenTextures(n, textures); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(textures), n * sizeof(GLuint)); + return 0; + } + } caller; + caller.n = n; + caller.textures = textures; + + msg.set_arg0(n); + msg.set_arg1(ToInt(textures)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGenTextures); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLuint index; + GLsizei bufsize; + GLsizei* length; + GLint* size; + GLenum* type; + GLchar* name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetActiveAttrib(program, index, bufsize, length, size, type, name); + return 0; + } + } caller; + caller.program = program; + caller.index = index; + caller.bufsize = bufsize; + caller.length = length; + caller.size = size; + caller.type = type; + caller.name = name; + + msg.set_arg0(program); + msg.set_arg1(index); + msg.set_arg2(bufsize); + msg.set_arg3(ToInt(length)); + msg.set_arg4(ToInt(size)); + msg.set_arg5(ToInt(type)); + msg.set_arg6(ToInt(name)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(name), strlen(name) * sizeof(GLchar)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetActiveAttrib); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLuint index; + GLsizei bufsize; + GLsizei* length; + GLint* size; + GLenum* type; + GLchar* name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetActiveUniform(program, index, bufsize, length, size, type, name); + return 0; + } + } caller; + caller.program = program; + caller.index = index; + caller.bufsize = bufsize; + caller.length = length; + caller.size = size; + caller.type = type; + caller.name = name; + + msg.set_arg0(program); + msg.set_arg1(index); + msg.set_arg2(bufsize); + msg.set_arg3(ToInt(length)); + msg.set_arg4(ToInt(size)); + msg.set_arg5(ToInt(type)); + msg.set_arg6(ToInt(name)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(name), strlen(name) * sizeof(GLchar)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetActiveUniform); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLsizei maxcount; + GLsizei* count; + GLuint* shaders; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetAttachedShaders(program, maxcount, count, shaders); + return 0; + } + } caller; + caller.program = program; + caller.maxcount = maxcount; + caller.count = count; + caller.shaders = shaders; + + msg.set_arg0(program); + msg.set_arg1(maxcount); + msg.set_arg2(ToInt(count)); + msg.set_arg3(ToInt(shaders)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetAttachedShaders); +} + +int Debug_glGetAttribLocation(GLuint program, const GLchar* name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + const GLchar* name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glGetAttribLocation(program, name)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.program = program; + caller.name = name; + + msg.set_arg0(program); + msg.set_arg1(ToInt(name)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(name), strlen(name) * sizeof(GLchar)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetAttribLocation); + return reinterpret_cast<int>(ret); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetBooleanv(GLenum pname, GLboolean* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum pname; + GLboolean* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetBooleanv(pname, params); + return 0; + } + } caller; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(pname); + msg.set_arg1(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetBooleanv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetBufferParameteriv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetBufferParameteriv); +} + +GLenum Debug_glGetError(void) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glGetError()); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetError); + return reinterpret_cast<GLenum>(ret); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetFloatv(GLenum pname, GLfloat* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum pname; + GLfloat* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetFloatv(pname, params); + return 0; + } + } caller; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(pname); + msg.set_arg1(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetFloatv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum attachment; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.attachment = attachment; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(attachment); + msg.set_arg2(pname); + msg.set_arg3(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetFramebufferAttachmentParameteriv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetIntegerv(GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetIntegerv(pname, params); + return 0; + } + } caller; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(pname); + msg.set_arg1(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetIntegerv); +} + +void Debug_glGetProgramiv(GLuint program, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGetProgramiv(program, pname, params); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(params), 1 * sizeof(GLint)); + return 0; + } + } caller; + caller.program = program; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(program); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetProgramiv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLsizei bufsize; + GLsizei* length; + GLchar* infolog; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGetProgramInfoLog(program, bufsize, length, infolog); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(infolog), strlen(infolog) * sizeof(GLchar)); + return 0; + } + } caller; + caller.program = program; + caller.bufsize = bufsize; + caller.length = length; + caller.infolog = infolog; + + msg.set_arg0(program); + msg.set_arg1(bufsize); + msg.set_arg2(ToInt(length)); + msg.set_arg3(ToInt(infolog)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetProgramInfoLog); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetRenderbufferParameteriv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetRenderbufferParameteriv); +} + +void Debug_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGetShaderiv(shader, pname, params); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(params), 1 * sizeof(GLint)); + return 0; + } + } caller; + caller.shader = shader; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(shader); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetShaderiv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + GLsizei bufsize; + GLsizei* length; + GLchar* infolog; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGetShaderInfoLog(shader, bufsize, length, infolog); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(infolog), strlen(infolog) * sizeof(GLchar)); + return 0; + } + } caller; + caller.shader = shader; + caller.bufsize = bufsize; + caller.length = length; + caller.infolog = infolog; + + msg.set_arg0(shader); + msg.set_arg1(bufsize); + msg.set_arg2(ToInt(length)); + msg.set_arg3(ToInt(infolog)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetShaderInfoLog); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum shadertype; + GLenum precisiontype; + GLint* range; + GLint* precision; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); + return 0; + } + } caller; + caller.shadertype = shadertype; + caller.precisiontype = precisiontype; + caller.range = range; + caller.precision = precision; + + msg.set_arg0(shadertype); + msg.set_arg1(precisiontype); + msg.set_arg2(ToInt(range)); + msg.set_arg3(ToInt(precision)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetShaderPrecisionFormat); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + GLsizei bufsize; + GLsizei* length; + GLchar* source; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glGetShaderSource(shader, bufsize, length, source); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.mutable_data()->assign(reinterpret_cast<const char *>(source), strlen(source) * sizeof(GLchar)); + return 0; + } + } caller; + caller.shader = shader; + caller.bufsize = bufsize; + caller.length = length; + caller.source = source; + + msg.set_arg0(shader); + msg.set_arg1(bufsize); + msg.set_arg2(ToInt(length)); + msg.set_arg3(ToInt(source)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetShaderSource); +} + +// FIXME: this function has pointers, it should be hand written +const GLubyte* Debug_glGetString(GLenum name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glGetString(name)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.name = name; + + msg.set_arg0(name); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetString); + return reinterpret_cast<const GLubyte*>(ret); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLfloat* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetTexParameterfv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetTexParameterfv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetTexParameteriv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetTexParameteriv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetUniformfv(GLuint program, GLint location, GLfloat* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLint location; + GLfloat* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetUniformfv(program, location, params); + return 0; + } + } caller; + caller.program = program; + caller.location = location; + caller.params = params; + + msg.set_arg0(program); + msg.set_arg1(location); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetUniformfv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetUniformiv(GLuint program, GLint location, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + GLint location; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetUniformiv(program, location, params); + return 0; + } + } caller; + caller.program = program; + caller.location = location; + caller.params = params; + + msg.set_arg0(program); + msg.set_arg1(location); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetUniformiv); +} + +int Debug_glGetUniformLocation(GLuint program, const GLchar* name) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + const GLchar* name; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glGetUniformLocation(program, name)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.program = program; + caller.name = name; + + msg.set_arg0(program); + msg.set_arg1(ToInt(name)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(name), strlen(name) * sizeof(GLchar)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetUniformLocation); + return reinterpret_cast<int>(ret); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint index; + GLenum pname; + GLfloat* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetVertexAttribfv(index, pname, params); + return 0; + } + } caller; + caller.index = index; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(index); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetVertexAttribfv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint index; + GLenum pname; + GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetVertexAttribiv(index, pname, params); + return 0; + } + } caller; + caller.index = index; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(index); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetVertexAttribiv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint index; + GLenum pname; + GLvoid** pointer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glGetVertexAttribPointerv(index, pname, pointer); + return 0; + } + } caller; + caller.index = index; + caller.pname = pname; + caller.pointer = pointer; + + msg.set_arg0(index); + msg.set_arg1(pname); + msg.set_arg2(ToInt(pointer)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glGetVertexAttribPointerv); +} + +void Debug_glHint(GLenum target, GLenum mode) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum mode; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glHint(target, mode); + return 0; + } + } caller; + caller.target = target; + caller.mode = mode; + + msg.set_arg0(target); + msg.set_arg1(mode); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glHint); +} + +GLboolean Debug_glIsBuffer(GLuint buffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint buffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsBuffer(buffer)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.buffer = buffer; + + msg.set_arg0(buffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsBuffer); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsEnabled(GLenum cap) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum cap; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsEnabled(cap)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.cap = cap; + + msg.set_arg0(cap); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsEnabled); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsFramebuffer(GLuint framebuffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint framebuffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsFramebuffer(framebuffer)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.framebuffer = framebuffer; + + msg.set_arg0(framebuffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsFramebuffer); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsProgram(GLuint program) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsProgram(program)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.program = program; + + msg.set_arg0(program); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsProgram); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsRenderbuffer(GLuint renderbuffer) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint renderbuffer; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsRenderbuffer(renderbuffer)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.renderbuffer = renderbuffer; + + msg.set_arg0(renderbuffer); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsRenderbuffer); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsShader(GLuint shader) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsShader(shader)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.shader = shader; + + msg.set_arg0(shader); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsShader); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +GLboolean Debug_glIsTexture(GLuint texture) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint texture; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + const int * ret = reinterpret_cast<const int *>(_c->glIsTexture(texture)); + msg.set_ret(ToInt(ret)); + return ret; + } + } caller; + caller.texture = texture; + + msg.set_arg0(texture); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glIsTexture); + return static_cast<GLboolean>(reinterpret_cast<int>(ret)); +} + +void Debug_glLineWidth(GLfloat width) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLfloat width; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glLineWidth(width); + return 0; + } + } caller; + caller.width = width; + + msg.set_arg0(ToInt(width)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glLineWidth); +} + +void Debug_glLinkProgram(GLuint program) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glLinkProgram(program); + return 0; + } + } caller; + caller.program = program; + + msg.set_arg0(program); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glLinkProgram); +} + +void Debug_glPixelStorei(GLenum pname, GLint param) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum pname; + GLint param; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glPixelStorei(pname, param); + return 0; + } + } caller; + caller.pname = pname; + caller.param = param; + + msg.set_arg0(pname); + msg.set_arg1(param); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glPixelStorei); +} + +void Debug_glPolygonOffset(GLfloat factor, GLfloat units) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLfloat factor; + GLfloat units; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glPolygonOffset(factor, units); + return 0; + } + } caller; + caller.factor = factor; + caller.units = units; + + msg.set_arg0(ToInt(factor)); + msg.set_arg1(ToInt(units)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glPolygonOffset); +} + +void Debug_glReleaseShaderCompiler(void) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glReleaseShaderCompiler(); + return 0; + } + } caller; + + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glReleaseShaderCompiler); +} + +void Debug_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum internalformat; + GLsizei width; + GLsizei height; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glRenderbufferStorage(target, internalformat, width, height); + return 0; + } + } caller; + caller.target = target; + caller.internalformat = internalformat; + caller.width = width; + caller.height = height; + + msg.set_arg0(target); + msg.set_arg1(internalformat); + msg.set_arg2(width); + msg.set_arg3(height); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glRenderbufferStorage); +} + +void Debug_glSampleCoverage(GLclampf value, GLboolean invert) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLclampf value; + GLboolean invert; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glSampleCoverage(value, invert); + return 0; + } + } caller; + caller.value = value; + caller.invert = invert; + + msg.set_arg0(ToInt(value)); + msg.set_arg1(invert); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glSampleCoverage); +} + +void Debug_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint x; + GLint y; + GLsizei width; + GLsizei height; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glScissor(x, y, width, height); + return 0; + } + } caller; + caller.x = x; + caller.y = y; + caller.width = width; + caller.height = height; + + msg.set_arg0(x); + msg.set_arg1(y); + msg.set_arg2(width); + msg.set_arg3(height); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glScissor); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLsizei n; + const GLuint* shaders; + GLenum binaryformat; + const GLvoid* binary; + GLsizei length; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glShaderBinary(n, shaders, binaryformat, binary, length); + return 0; + } + } caller; + caller.n = n; + caller.shaders = shaders; + caller.binaryformat = binaryformat; + caller.binary = binary; + caller.length = length; + + msg.set_arg0(n); + msg.set_arg1(ToInt(shaders)); + msg.set_arg2(binaryformat); + msg.set_arg3(ToInt(binary)); + msg.set_arg4(length); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glShaderBinary); +} + +void Debug_glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint shader; + GLsizei count; + const GLchar** string; + const GLint* length; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glShaderSource(shader, count, string, length); + return 0; + } + } caller; + caller.shader = shader; + caller.count = count; + caller.string = string; + caller.length = length; + + msg.set_arg0(shader); + msg.set_arg1(count); + msg.set_arg2(ToInt(string)); + msg.set_arg3(ToInt(length)); + + // FIXME: check for pointer usage + EXTEND_Debug_glShaderSource; + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glShaderSource); +} + +void Debug_glStencilFunc(GLenum func, GLint ref, GLuint mask) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum func; + GLint ref; + GLuint mask; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilFunc(func, ref, mask); + return 0; + } + } caller; + caller.func = func; + caller.ref = ref; + caller.mask = mask; + + msg.set_arg0(func); + msg.set_arg1(ref); + msg.set_arg2(mask); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilFunc); +} + +void Debug_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum face; + GLenum func; + GLint ref; + GLuint mask; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilFuncSeparate(face, func, ref, mask); + return 0; + } + } caller; + caller.face = face; + caller.func = func; + caller.ref = ref; + caller.mask = mask; + + msg.set_arg0(face); + msg.set_arg1(func); + msg.set_arg2(ref); + msg.set_arg3(mask); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilFuncSeparate); +} + +void Debug_glStencilMask(GLuint mask) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint mask; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilMask(mask); + return 0; + } + } caller; + caller.mask = mask; + + msg.set_arg0(mask); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilMask); +} + +void Debug_glStencilMaskSeparate(GLenum face, GLuint mask) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum face; + GLuint mask; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilMaskSeparate(face, mask); + return 0; + } + } caller; + caller.face = face; + caller.mask = mask; + + msg.set_arg0(face); + msg.set_arg1(mask); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilMaskSeparate); +} + +void Debug_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum fail; + GLenum zfail; + GLenum zpass; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilOp(fail, zfail, zpass); + return 0; + } + } caller; + caller.fail = fail; + caller.zfail = zfail; + caller.zpass = zpass; + + msg.set_arg0(fail); + msg.set_arg1(zfail); + msg.set_arg2(zpass); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilOp); +} + +void Debug_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum face; + GLenum fail; + GLenum zfail; + GLenum zpass; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glStencilOpSeparate(face, fail, zfail, zpass); + return 0; + } + } caller; + caller.face = face; + caller.fail = fail; + caller.zfail = zfail; + caller.zpass = zpass; + + msg.set_arg0(face); + msg.set_arg1(fail); + msg.set_arg2(zfail); + msg.set_arg3(zpass); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glStencilOpSeparate); +} + +void Debug_glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLfloat param; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glTexParameterf(target, pname, param); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.param = param; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(param)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexParameterf); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + const GLfloat* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glTexParameterfv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexParameterfv); +} + +void Debug_glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + GLint param; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glTexParameteri(target, pname, param); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.param = param; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(param); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexParameteri); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glTexParameteriv(GLenum target, GLenum pname, const GLint* params) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLenum pname; + const GLint* params; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glTexParameteriv(target, pname, params); + return 0; + } + } caller; + caller.target = target; + caller.pname = pname; + caller.params = params; + + msg.set_arg0(target); + msg.set_arg1(pname); + msg.set_arg2(ToInt(params)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexParameteriv); +} + +void Debug_glUniform1f(GLint location, GLfloat x) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLfloat x; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform1f(location, x); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + + msg.set_arg0(location); + msg.set_arg1(ToInt(x)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform1f); +} + +void Debug_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLfloat* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform1fv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 1*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform1fv); +} + +void Debug_glUniform1i(GLint location, GLint x) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLint x; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform1i(location, x); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + + msg.set_arg0(location); + msg.set_arg1(x); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform1i); +} + +void Debug_glUniform1iv(GLint location, GLsizei count, const GLint* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLint* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform1iv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 1*count * sizeof(GLint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform1iv); +} + +void Debug_glUniform2f(GLint location, GLfloat x, GLfloat y) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLfloat x; + GLfloat y; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform2f(location, x, y); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + + msg.set_arg0(location); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform2f); +} + +void Debug_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLfloat* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform2fv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 2*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform2fv); +} + +void Debug_glUniform2i(GLint location, GLint x, GLint y) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLint x; + GLint y; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform2i(location, x, y); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + + msg.set_arg0(location); + msg.set_arg1(x); + msg.set_arg2(y); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform2i); +} + +void Debug_glUniform2iv(GLint location, GLsizei count, const GLint* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLint* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform2iv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 2*count * sizeof(GLint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform2iv); +} + +void Debug_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLfloat x; + GLfloat y; + GLfloat z; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform3f(location, x, y, z); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + caller.z = z; + + msg.set_arg0(location); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + msg.set_arg3(ToInt(z)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform3f); +} + +void Debug_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLfloat* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform3fv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 3*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform3fv); +} + +void Debug_glUniform3i(GLint location, GLint x, GLint y, GLint z) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLint x; + GLint y; + GLint z; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform3i(location, x, y, z); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + caller.z = z; + + msg.set_arg0(location); + msg.set_arg1(x); + msg.set_arg2(y); + msg.set_arg3(z); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform3i); +} + +void Debug_glUniform3iv(GLint location, GLsizei count, const GLint* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLint* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform3iv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 3*count * sizeof(GLint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform3iv); +} + +void Debug_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLfloat x; + GLfloat y; + GLfloat z; + GLfloat w; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform4f(location, x, y, z, w); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + caller.z = z; + caller.w = w; + + msg.set_arg0(location); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + msg.set_arg3(ToInt(z)); + msg.set_arg4(ToInt(w)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform4f); +} + +void Debug_glUniform4fv(GLint location, GLsizei count, const GLfloat* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLfloat* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform4fv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 4*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform4fv); +} + +void Debug_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLint x; + GLint y; + GLint z; + GLint w; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform4i(location, x, y, z, w); + return 0; + } + } caller; + caller.location = location; + caller.x = x; + caller.y = y; + caller.z = z; + caller.w = w; + + msg.set_arg0(location); + msg.set_arg1(x); + msg.set_arg2(y); + msg.set_arg3(z); + msg.set_arg4(w); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform4i); +} + +void Debug_glUniform4iv(GLint location, GLsizei count, const GLint* v) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + const GLint* v; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniform4iv(location, count, v); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.v = v; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(ToInt(v)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(v), 4*count * sizeof(GLint)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniform4iv); +} + +void Debug_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + GLboolean transpose; + const GLfloat* value; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniformMatrix2fv(location, count, transpose, value); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.transpose = transpose; + caller.value = value; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(transpose); + msg.set_arg3(ToInt(value)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(value), 4*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniformMatrix2fv); +} + +void Debug_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + GLboolean transpose; + const GLfloat* value; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniformMatrix3fv(location, count, transpose, value); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.transpose = transpose; + caller.value = value; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(transpose); + msg.set_arg3(ToInt(value)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(value), 9*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniformMatrix3fv); +} + +void Debug_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint location; + GLsizei count; + GLboolean transpose; + const GLfloat* value; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUniformMatrix4fv(location, count, transpose, value); + return 0; + } + } caller; + caller.location = location; + caller.count = count; + caller.transpose = transpose; + caller.value = value; + + msg.set_arg0(location); + msg.set_arg1(count); + msg.set_arg2(transpose); + msg.set_arg3(ToInt(value)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(value), 16*count * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUniformMatrix4fv); +} + +void Debug_glUseProgram(GLuint program) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glUseProgram(program); + getDbgContextThreadSpecific()->glUseProgram(program); + return 0; + } + } caller; + caller.program = program; + + msg.set_arg0(program); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glUseProgram); +} + +void Debug_glValidateProgram(GLuint program) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint program; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glValidateProgram(program); + return 0; + } + } caller; + caller.program = program; + + msg.set_arg0(program); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glValidateProgram); +} + +void Debug_glVertexAttrib1f(GLuint indx, GLfloat x) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + GLfloat x; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib1f(indx, x); + return 0; + } + } caller; + caller.indx = indx; + caller.x = x; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(x)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib1f); +} + +void Debug_glVertexAttrib1fv(GLuint indx, const GLfloat* values) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + const GLfloat* values; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib1fv(indx, values); + return 0; + } + } caller; + caller.indx = indx; + caller.values = values; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(values)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(values), 1 * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib1fv); +} + +void Debug_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + GLfloat x; + GLfloat y; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib2f(indx, x, y); + return 0; + } + } caller; + caller.indx = indx; + caller.x = x; + caller.y = y; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib2f); +} + +void Debug_glVertexAttrib2fv(GLuint indx, const GLfloat* values) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + const GLfloat* values; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib2fv(indx, values); + return 0; + } + } caller; + caller.indx = indx; + caller.values = values; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(values)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(values), 2 * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib2fv); +} + +void Debug_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + GLfloat x; + GLfloat y; + GLfloat z; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib3f(indx, x, y, z); + return 0; + } + } caller; + caller.indx = indx; + caller.x = x; + caller.y = y; + caller.z = z; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + msg.set_arg3(ToInt(z)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib3f); +} + +void Debug_glVertexAttrib3fv(GLuint indx, const GLfloat* values) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + const GLfloat* values; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib3fv(indx, values); + return 0; + } + } caller; + caller.indx = indx; + caller.values = values; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(values)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(values), 3 * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib3fv); +} + +void Debug_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + GLfloat x; + GLfloat y; + GLfloat z; + GLfloat w; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib4f(indx, x, y, z, w); + return 0; + } + } caller; + caller.indx = indx; + caller.x = x; + caller.y = y; + caller.z = z; + caller.w = w; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(x)); + msg.set_arg2(ToInt(y)); + msg.set_arg3(ToInt(z)); + msg.set_arg4(ToInt(w)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib4f); +} + +void Debug_glVertexAttrib4fv(GLuint indx, const GLfloat* values) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + const GLfloat* values; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttrib4fv(indx, values); + return 0; + } + } caller; + caller.indx = indx; + caller.values = values; + + msg.set_arg0(indx); + msg.set_arg1(ToInt(values)); + + // FIXME: check for pointer usage + msg.mutable_data()->assign(reinterpret_cast<const char *>(values), 4 * sizeof(GLfloat)); + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttrib4fv); +} + +// FIXME: this function has pointers, it should be hand written +void Debug_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLuint indx; + GLint size; + GLenum type; + GLboolean normalized; + GLsizei stride; + const GLvoid* ptr; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glVertexAttribPointer(indx, size, type, normalized, stride, ptr); + getDbgContextThreadSpecific()->glVertexAttribPointer(indx, size, type, normalized, stride, ptr); + return 0; + } + } caller; + caller.indx = indx; + caller.size = size; + caller.type = type; + caller.normalized = normalized; + caller.stride = stride; + caller.ptr = ptr; + + msg.set_arg0(indx); + msg.set_arg1(size); + msg.set_arg2(type); + msg.set_arg3(normalized); + msg.set_arg4(stride); + msg.set_arg5(ToInt(ptr)); + + // FIXME: check for pointer usage + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glVertexAttribPointer); +} + +void Debug_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLint x; + GLint y; + GLsizei width; + GLsizei height; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + _c->glViewport(x, y, width, height); + return 0; + } + } caller; + caller.x = x; + caller.y = y; + caller.width = width; + caller.height = height; + + msg.set_arg0(x); + msg.set_arg1(y); + msg.set_arg2(width); + msg.set_arg3(height); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glViewport); +} + +// FIXME: the following functions should be written by hand +void Debug_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void Debug_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void Debug_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void Debug_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void Debug_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); +void Debug_glGetBooleanv(GLenum pname, GLboolean* params); +void Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); +void Debug_glGetFloatv(GLenum pname, GLfloat* params); +void Debug_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params); +void Debug_glGetIntegerv(GLenum pname, GLint* params); +void Debug_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void Debug_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params); +void Debug_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void Debug_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); +void Debug_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); +const GLubyte* Debug_glGetString(GLenum name); +void Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); +void Debug_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); +void Debug_glGetUniformfv(GLuint program, GLint location, GLfloat* params); +void Debug_glGetUniformiv(GLuint program, GLint location, GLint* params); +void Debug_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); +void Debug_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); +void Debug_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer); +void Debug_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length); +void Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params); +void Debug_glTexParameteriv(GLenum target, GLenum pname, const GLint* params); +void Debug_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); |