diff options
Diffstat (limited to 'opengl/libs')
23 files changed, 8771 insertions, 9 deletions
diff --git a/opengl/libs/Android.mk b/opengl/libs/Android.mk index c8041fc..123306b 100644 --- a/opengl/libs/Android.mk +++ b/opengl/libs/Android.mk @@ -13,11 +13,11 @@ LOCAL_SRC_FILES:= \ EGL/hooks.cpp \ EGL/Loader.cpp \ # - -LOCAL_SHARED_LIBRARIES += libcutils libutils +LOCAL_STATIC_LIBRARIES += libGLESv2_dbg libprotobuf-cpp-2.3.0-lite +LOCAL_SHARED_LIBRARIES += libcutils libutils libstlport LOCAL_LDLIBS := -lpthread -ldl LOCAL_MODULE:= libEGL - +LOCAL_LDFLAGS += -Wl,--exclude-libs=ALL # needed on sim build because of weird logging issues ifeq ($(TARGET_SIMULATOR),true) else @@ -164,3 +164,6 @@ LOCAL_LDLIBS := -lpthread -ldl LOCAL_MODULE:= libETC1 include $(BUILD_SHARED_LIBRARY) + +include $(call all-makefiles-under,$(LOCAL_PATH)) + diff --git a/opengl/libs/EGL/Loader.cpp b/opengl/libs/EGL/Loader.cpp index 747c829..2502f15 100644 --- a/opengl/libs/EGL/Loader.cpp +++ b/opengl/libs/EGL/Loader.cpp @@ -30,6 +30,7 @@ #include "egl_impl.h" #include "Loader.h" +#include "glesv2dbg.h" // ---------------------------------------------------------------------------- namespace android { @@ -114,6 +115,7 @@ Loader::Loader() Loader::~Loader() { + StopDebugServer(); } const char* Loader::getTag(int dpy, int impl) diff --git a/opengl/libs/EGL/egl.cpp b/opengl/libs/EGL/egl.cpp index e13af1c..e567c88 100644 --- a/opengl/libs/EGL/egl.cpp +++ b/opengl/libs/EGL/egl.cpp @@ -45,6 +45,7 @@ #include "hooks.h" #include "egl_impl.h" #include "Loader.h" +#include "glesv2dbg.h" #define setError(_e, _r) setErrorEtc(__FUNCTION__, __LINE__, _e, _r) @@ -223,9 +224,15 @@ struct egl_context_t : public egl_object_t egl_context_t(EGLDisplay dpy, EGLContext context, EGLConfig config, int impl, egl_connection_t const* cnx, int version) : dpy(dpy), context(context), config(config), read(0), draw(0), impl(impl), - cnx(cnx), version(version) + cnx(cnx), version(version), dbg(NULL) { } + ~egl_context_t() + { + if (dbg) + DestroyDbgContext(dbg); + dbg = NULL; + } EGLDisplay dpy; EGLContext context; EGLConfig config; @@ -234,6 +241,7 @@ struct egl_context_t : public egl_object_t int impl; egl_connection_t const* cnx; int version; + DbgContext * dbg; }; struct egl_image_t : public egl_object_t @@ -296,9 +304,9 @@ EGLAPI pthread_key_t gGLTraceKey = -1; // ---------------------------------------------------------------------------- -static int gEGLTraceLevel; +static int gEGLTraceLevel, gEGLDebugLevel; static int gEGLApplicationTraceLevel; -extern EGLAPI gl_hooks_t gHooksTrace; +extern EGLAPI gl_hooks_t gHooksTrace, gHooksDebug; static inline void setGlTraceThreadSpecific(gl_hooks_t const *value) { pthread_setspecific(gGLTraceKey, value); @@ -314,12 +322,35 @@ static void initEglTraceLevel() { int propertyLevel = atoi(value); int applicationLevel = gEGLApplicationTraceLevel; gEGLTraceLevel = propertyLevel > applicationLevel ? propertyLevel : applicationLevel; + + property_get("debug.egl.debug_proc", value, ""); + long pid = getpid(); + char procPath[128] = {}; + sprintf(procPath, "/proc/%ld/cmdline", pid); + FILE * file = fopen(procPath, "r"); + if (file) + { + char cmdline[256] = {}; + if (fgets(cmdline, sizeof(cmdline) - 1, file)) + { + if (!strcmp(value, cmdline)) + gEGLDebugLevel = 1; + } + fclose(file); + } + + if (gEGLDebugLevel > 0) + StartDebugServer(); } static void setGLHooksThreadSpecific(gl_hooks_t const *value) { if (gEGLTraceLevel > 0) { setGlTraceThreadSpecific(value); setGlThreadSpecific(&gHooksTrace); + } else if (gEGLDebugLevel > 0 && value != &gHooksNoContext) { + setGlTraceThreadSpecific(value); + setGlThreadSpecific(&gHooksDebug); + LOGD("\n* setGLHooksThreadSpecific gHooksDebug"); } else { setGlThreadSpecific(value); } @@ -561,6 +592,11 @@ egl_context_t* get_context(EGLContext context) { return egl_to_native_cast<egl_context_t>(context); } +DbgContext * getDbgContextThreadSpecific() +{ + return get_context(getContext())->dbg; +} + static inline egl_image_t* get_image(EGLImageKHR image) { return egl_to_native_cast<egl_image_t>(image); @@ -1378,6 +1414,8 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, loseCurrent(cur_c); if (ctx != EGL_NO_CONTEXT) { + if (!c->dbg && gEGLDebugLevel > 0) + c->dbg = CreateDbgContext(c->version, c->cnx->hooks[c->version]); setGLHooksThreadSpecific(c->cnx->hooks[c->version]); setContext(ctx); _c.acquire(); @@ -1607,7 +1645,7 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) cnx->hooks[GLESv1_INDEX]->ext.extensions[slot] = cnx->hooks[GLESv2_INDEX]->ext.extensions[slot] = #if EGL_TRACE - gHooksTrace.ext.extensions[slot] = + gHooksDebug.ext.extensions[slot] = gHooksTrace.ext.extensions[slot] = #endif cnx->egl.eglGetProcAddress(procname); } @@ -1635,6 +1673,10 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) { + EGLBoolean Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface draw); + if (gEGLDebugLevel > 0) + Debug_eglSwapBuffers(dpy, draw); + clearError(); SurfaceRef _s(draw); diff --git a/opengl/libs/EGL/trace.cpp b/opengl/libs/EGL/trace.cpp index d3e96ba..f3e101b 100644 --- a/opengl/libs/EGL/trace.cpp +++ b/opengl/libs/EGL/trace.cpp @@ -325,7 +325,7 @@ static void Tracing_ ## _api _args { \ #define TRACE_GL(_type, _api, _args, _argList, ...) \ static _type Tracing_ ## _api _args { \ - TraceGL(#_api, __VA_ARGS__); \ + TraceGL(#_api, __VA_ARGS__); \ gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl; \ return _c->_api _argList; \ } @@ -333,11 +333,11 @@ static _type Tracing_ ## _api _args { \ extern "C" { #include "../trace.in" } + #undef TRACE_GL_VOID #undef TRACE_GL #define GL_ENTRY(_r, _api, ...) Tracing_ ## _api, - EGLAPI gl_hooks_t gHooksTrace = { { #include "entries.in" @@ -348,6 +348,48 @@ EGLAPI gl_hooks_t gHooksTrace = { }; #undef GL_ENTRY + +#undef TRACE_GL_VOID +#undef TRACE_GL + +// define the ES 1.0 Debug_gl* functions as Tracing_gl functions +#define TRACE_GL_VOID(_api, _args, _argList, ...) \ +static void Debug_ ## _api _args { \ + TraceGL(#_api, __VA_ARGS__); \ + gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl; \ + _c->_api _argList; \ +} + +#define TRACE_GL(_type, _api, _args, _argList, ...) \ +static _type Debug_ ## _api _args { \ + TraceGL(#_api, __VA_ARGS__); \ + gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl; \ + return _c->_api _argList; \ +} + +extern "C" { +#include "../debug.in" +} + +#undef TRACE_GL_VOID +#undef TRACE_GL + +// declare all Debug_gl* functions +#define GL_ENTRY(_r, _api, ...) _r Debug_##_api ( __VA_ARGS__ ); +#include "glesv2dbg_functions.h" +#undef GL_ENTRY + +#define GL_ENTRY(_r, _api, ...) Debug_ ## _api, +EGLAPI gl_hooks_t gHooksDebug = { + { + #include "entries.in" + }, + { + {0} + } +}; +#undef GL_ENTRY + // ---------------------------------------------------------------------------- }; // namespace android // ---------------------------------------------------------------------------- diff --git a/opengl/libs/GLES2_dbg/Android.mk b/opengl/libs/GLES2_dbg/Android.mk new file mode 100644 index 0000000..e593c32 --- /dev/null +++ b/opengl/libs/GLES2_dbg/Android.mk @@ -0,0 +1,45 @@ +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + src/api.cpp \ + src/dbgcontext.cpp \ + src/debugger_message.pb.cpp \ + src/egl.cpp \ + src/server.cpp \ + src/texture.cpp \ + src/vertex.cpp + +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH) \ + $(LOCAL_PATH)/../ \ + external/stlport/stlport \ + external/protobuf/src \ + bionic + +#LOCAL_CFLAGS += -O0 -g -DDEBUG -UNDEBUG +LOCAL_CFLAGS := -DGOOGLE_PROTOBUF_NO_RTTI + +ifeq ($(TARGET_ARCH),arm) + LOCAL_CFLAGS += -fstrict-aliasing +endif + +ifeq ($(ARCH_ARM_HAVE_TLS_REGISTER),true) + LOCAL_CFLAGS += -DHAVE_ARM_TLS_REGISTER +endif + +ifneq ($(TARGET_SIMULATOR),true) + # we need to access the private Bionic header <bionic_tls.h> + # on ARM platforms, we need to mirror the ARCH_ARM_HAVE_TLS_REGISTER + # behavior from the bionic Android.mk file + ifeq ($(TARGET_ARCH)-$(ARCH_ARM_HAVE_TLS_REGISTER),arm-true) + LOCAL_CFLAGS += -DHAVE_ARM_TLS_REGISTER + endif + LOCAL_C_INCLUDES += bionic/libc/private +endif + +LOCAL_MODULE:= libGLESv2_dbg +LOCAL_MODULE_TAGS := optional + +include $(BUILD_STATIC_LIBRARY) diff --git a/opengl/libs/GLES2_dbg/generate_api_cpp.py b/opengl/libs/GLES2_dbg/generate_api_cpp.py new file mode 100755 index 0000000..5b024ad --- /dev/null +++ b/opengl/libs/GLES2_dbg/generate_api_cpp.py @@ -0,0 +1,207 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# 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. +# + +import os +import sys + +def RemoveAnnotation(line): + if line.find(":") >= 0: + annotation = line[line.find(":"): line.find(" ", line.find(":"))] + return line.replace(annotation, "*") + else: + return line + +def generate_api(lines): + externs = [] + i = 0 + # these have been hand written + skipFunctions = ["glTexImage2D", "glTexSubImage2D", "glReadPixels", +"glDrawArrays", "glDrawElements"] + + # these have an EXTEND_Debug_* macro for getting data + extendFunctions = ["glCopyTexImage2D", "glCopyTexSubImage2D", "glShaderSource"] + + # these also needs to be forwarded to DbgContext + contextFunctions = ["glUseProgram", "glEnableVertexAttribArray", "glDisableVertexAttribArray", +"glVertexAttribPointer", "glBindBuffer", "glBufferData", "glBufferSubData", "glDeleteBuffers",] + + for line in lines: + if line.find("API_ENTRY(") >= 0: # a function prototype + returnType = line[0: line.find(" API_ENTRY(")] + functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name + parameterList = line[line.find(")(") + 2: line.find(") {")] + + #if line.find("*") >= 0: + # extern = "%s Debug_%s(%s);" % (returnType, functionName, parameterList) + # externs.append(extern) + # continue + + if functionName in skipFunctions: + sys.stderr.write("!\n! skipping function '%s'\n!\n" % (functionName)) + continue + + parameters = parameterList.split(',') + paramIndex = 0 + if line.find("*") >= 0 and (line.find("*") < line.find(":") or line.find("*") > line.rfind(":")): # unannotated pointer + if not functionName in extendFunctions: + # add function to list of functions that should be hand written, but generate code anyways + extern = "%s Debug_%s(%s);" % (returnType, functionName, RemoveAnnotation(parameterList)) + sys.stderr.write("%s should be hand written\n" % (extern)) + print "// FIXME: this function has pointers, it should be hand written" + externs.append(extern) + + print "%s Debug_%s(%s)\n{" % (returnType, functionName, RemoveAnnotation(parameterList)) + print """ glesv2debugger::Message msg; + const bool expectResponse = false;""" + + if parameterList == "void": + parameters = [] + arguments = "" + paramNames = [] + inout = "" + getData = "" + + callerMembers = "" + setCallerMembers = "" + setMsgParameters = "" + + for parameter in parameters: + const = parameter.find("const") + parameter = parameter.replace("const", "") + parameter = parameter.strip() + paramType = parameter.split(' ')[0] + paramName = parameter.split(' ')[1] + annotation = "" + arguments += paramName + if parameter.find(":") >= 0: # has annotation + assert inout == "" # only one parameter should be annotated + sys.stderr.write("%s is annotated: %s \n" % (functionName, paramType)) + inout = paramType.split(":")[2] + annotation = paramType.split(":")[1] + paramType = paramType.split(":")[0] + count = 1 + countArg = "" + if annotation.find("*") >= 0: # [1,n] * param + count = int(annotation.split("*")[0]) + countArg = annotation.split("*")[1] + assert countArg in paramNames + elif annotation in paramNames: + count = 1 + countArg = annotation + elif annotation == "GLstring": + annotation = "strlen(%s)" % (paramName) + else: + count = int(annotation) + + setMsgParameters += " msg.set_arg%d(ToInt(%s));\n" % (paramIndex, paramName) + if paramType.find("void") >= 0: + getData += " msg.mutable_data()->assign(reinterpret_cast<const char *>(%s), %s * sizeof(char));" % (paramName, annotation) + else: + getData += " msg.mutable_data()->assign(reinterpret_cast<const char *>(%s), %s * sizeof(%s));" % (paramName, annotation, paramType) + paramType += "*" + else: + if paramType == "GLfloat" or paramType == "GLclampf" or paramType.find("*") >= 0: + setMsgParameters += " msg.set_arg%d(ToInt(%s));\n" % (paramIndex, paramName) + else: + setMsgParameters += " msg.set_arg%d(%s);\n" % (paramIndex, paramName) + if paramIndex < len(parameters) - 1: + arguments += ', ' + if const >= 0: + paramType = "const " + paramType + paramNames.append(paramName) + paramIndex += 1 + callerMembers += " %s %s;\n" % (paramType, paramName) + setCallerMembers += " caller.%s = %s;\n" % (paramName, paramName) + + print " struct : public FunctionCall {" + print callerMembers + print " const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) {" + if inout in ["out", "inout"]: # get timing excluding output data copy + print " nsecs_t c0 = systemTime(timeMode);" + if returnType == "void": + print " _c->%s(%s);" % (functionName, arguments) + else: + print " const int * ret = reinterpret_cast<const int *>(_c->%s(%s));" % (functionName, arguments) + print " msg.set_ret(ToInt(ret));" + if inout in ["out", "inout"]: + print " msg.set_time((systemTime(timeMode) - c0) * 1e-6f);" + print " " + getData + if functionName in contextFunctions: + print " getDbgContextThreadSpecific()->%s(%s);" % (functionName, arguments) + if returnType == "void": + print " return 0;" + else: + print " return ret;" + print """ } + } caller;""" + print setCallerMembers + print setMsgParameters + + if line.find("*") >= 0 or line.find(":") >= 0: + print " // FIXME: check for pointer usage" + if inout in ["in", "inout"]: + print getData + if functionName in extendFunctions: + print " EXTEND_Debug_%s;" % (functionName) + print " int * ret = MessageLoop(caller, msg, expectResponse," + print " glesv2debugger::Message_Function_%s);" % (functionName) + if returnType != "void": + if returnType == "GLboolean": + print " return static_cast<GLboolean>(reinterpret_cast<int>(ret));" + else: + print " return reinterpret_cast<%s>(ret);" % (returnType) + print "}\n" + + + print "// FIXME: the following functions should be written by hand" + for extern in externs: + print extern + +if __name__ == "__main__": + print """\ +/* + ** 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; } +""" + lines = open("gl2_api_annotated.in").readlines() + generate_api(lines) + #lines = open("gl2ext_api.in").readlines() + #generate_api(lines) + + diff --git a/opengl/libs/GLES2_dbg/generate_debug_in.py b/opengl/libs/GLES2_dbg/generate_debug_in.py new file mode 100755 index 0000000..1280c6f --- /dev/null +++ b/opengl/libs/GLES2_dbg/generate_debug_in.py @@ -0,0 +1,80 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# 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. +# + +import os +import sys + +def append_functions(functions, lines): + i = 0 + for line in lines: + if line.find("API_ENTRY(") >= 0: # a function prototype + returnType = line[0: line.find(" API_ENTRY(")] + functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name + parameterList = line[line.find(")(") + 2: line.find(") {")] + + functions.append(functionName) + #print functionName + continue + + parameters = parameterList.split(',') + paramIndex = 0 + if line.find("*") >= 0: + print "// FIXME: this function has pointers, it should be hand written" + externs.append("%s Tracing_%s(%s);" % (returnType, functionName, parameterList)) + print "%s Tracing_%s(%s)\n{" % (returnType, functionName, parameterList) + + if parameterList == "void": + parameters = [] + + arguments = "" + + for parameter in parameters: + parameter = parameter.replace("const", "") + parameter = parameter.strip() + paramType = parameter.split(' ')[0] + paramName = parameter.split(' ')[1] + + paramIndex += 1 + + return functions + + + +if __name__ == "__main__": + definedFunctions = [] + lines = open("gl2_api_annotated.in").readlines() + definedFunctions = append_functions(definedFunctions, lines) + + output = open("../debug.in", "w") + lines = open("../trace.in").readlines() + output.write("// the following functions are not defined in GLESv2_dbg\n") + for line in lines: + functionName = "" + if line.find("TRACE_GL(") >= 0: # a function prototype + functionName = line.split(',')[1].strip() + elif line.find("TRACE_GL_VOID(") >= 0: # a function prototype + functionName = line[line.find("(") + 1: line.find(",")] #extract GL function name + else: + continue + if functionName in definedFunctions: + #print functionName + continue + else: + output.write(line) + diff --git a/opengl/libs/GLES2_dbg/generate_debugger_message_proto.py b/opengl/libs/GLES2_dbg/generate_debugger_message_proto.py new file mode 100755 index 0000000..b14885b --- /dev/null +++ b/opengl/libs/GLES2_dbg/generate_debugger_message_proto.py @@ -0,0 +1,139 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# 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. +# + +import os + +def generate_egl_entries(output, lines, i): + for line in lines: + if line.find("EGL_ENTRY(") >= 0: + line = line.split(",")[1].strip() #extract EGL function name + output.write(" %s = %d;\n" % (line, i)) + i += 1 + return i + + +def generate_gl_entries(output,lines,i): + for line in lines: + if line.find("API_ENTRY(") >= 0: + line = line[line.find("(") + 1: line.find(")")] #extract GL function name + output.write(" %s = %d;\n" % (line, i)) + i += 1 + return i + + +if __name__ == "__main__": + output = open("debugger_message.proto",'w') + output.write("""\ +/* + * Copyright (C) 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. + */ + +// do not edit; auto generated by generate_debugger_message_proto.py + +package com.android.glesv2debugger; + +option optimize_for = LITE_RUNTIME; + +message Message +{ + required int32 context_id = 1; // GL context id + enum Function + { +""") + + i = 0; + + lines = open("gl2_api_annotated.in").readlines() + i = generate_gl_entries(output, lines, i) + output.write(" // end of GL functions\n") + + #lines = open("gl2ext_api.in").readlines() + #i = generate_gl_entries(output, lines, i) + #output.write(" // end of GL EXT functions\n") + + lines = open("../EGL/egl_entries.in").readlines() + i = generate_egl_entries(output, lines, i) + output.write(" // end of GL EXT functions\n") + + output.write(" ACK = %d;\n" % (i)) + i += 1 + + output.write(" NEG = %d;\n" % (i)) + i += 1 + + output.write(" CONTINUE = %d;\n" % (i)) + i += 1 + + output.write(" SKIP = %d;\n" % (i)) + i += 1 + + output.write(" SETPROP = %d;\n" % (i)) + i += 1 + + output.write(" CAPTURE = %d;\n" % (i)) + i += 1 + + output.write(""" } + required Function function = 2 [default = NEG]; // type/function of message + enum Type + { + BeforeCall = 0; + AfterCall = 1; + Response = 2; // currently used for misc messages + } + required Type type = 3; + required bool expect_response = 4; + optional int32 ret = 5; // return value from previous GL call + optional int32 arg0 = 6; // args to GL call + optional int32 arg1 = 7; + optional int32 arg2 = 8; + optional int32 arg3 = 9; + optional int32 arg4 = 16; + optional int32 arg5 = 17; + optional int32 arg6 = 18; + optional int32 arg7 = 19; + optional int32 arg8 = 20; + optional bytes data = 10; // variable length data used for GL call + optional float time = 11; // duration of previous GL call (ms) + enum Prop + { + Capture = 0; // arg0 = true | false + TimeMode = 1; // arg0 = SYSTEM_TIME_* in utils/Timers.h + }; + optional Prop prop = 21; // used with SETPROP, value in arg0 + optional float clock = 22; // wall clock in seconds +} +""") + + output.close() + + os.system("aprotoc --cpp_out=src --java_out=../../../../../development/tools/glesv2debugger/src debugger_message.proto") + os.system('mv -f "src/debugger_message.pb.cc" "src/debugger_message.pb.cpp"') diff --git a/opengl/libs/GLES2_dbg/gl2_api_annotated.in b/opengl/libs/GLES2_dbg/gl2_api_annotated.in new file mode 100644 index 0000000..227e2eb --- /dev/null +++ b/opengl/libs/GLES2_dbg/gl2_api_annotated.in @@ -0,0 +1,426 @@ +void API_ENTRY(glActiveTexture)(GLenum texture) { + CALL_GL_API(glActiveTexture, texture); +} +void API_ENTRY(glAttachShader)(GLuint program, GLuint shader) { + CALL_GL_API(glAttachShader, program, shader); +} +void API_ENTRY(glBindAttribLocation)(GLuint program, GLuint index, const GLchar:GLstring:in name) { + CALL_GL_API(glBindAttribLocation, program, index, name); +} +void API_ENTRY(glBindBuffer)(GLenum target, GLuint buffer) { + CALL_GL_API(glBindBuffer, target, buffer); +} +void API_ENTRY(glBindFramebuffer)(GLenum target, GLuint framebuffer) { + CALL_GL_API(glBindFramebuffer, target, framebuffer); +} +void API_ENTRY(glBindRenderbuffer)(GLenum target, GLuint renderbuffer) { + CALL_GL_API(glBindRenderbuffer, target, renderbuffer); +} +void API_ENTRY(glBindTexture)(GLenum target, GLuint texture) { + CALL_GL_API(glBindTexture, target, texture); +} +void API_ENTRY(glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + CALL_GL_API(glBlendColor, red, green, blue, alpha); +} +void API_ENTRY(glBlendEquation)( GLenum mode ) { + CALL_GL_API(glBlendEquation, mode); +} +void API_ENTRY(glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha) { + CALL_GL_API(glBlendEquationSeparate, modeRGB, modeAlpha); +} +void API_ENTRY(glBlendFunc)(GLenum sfactor, GLenum dfactor) { + CALL_GL_API(glBlendFunc, sfactor, dfactor); +} +void API_ENTRY(glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { + CALL_GL_API(glBlendFuncSeparate, srcRGB, dstRGB, srcAlpha, dstAlpha); +} +void API_ENTRY(glBufferData)(GLenum target, GLsizeiptr size, const GLvoid:size:in data, GLenum usage) { + CALL_GL_API(glBufferData, target, size, data, usage); +} +void API_ENTRY(glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid:size:in data) { + CALL_GL_API(glBufferSubData, target, offset, size, data); +} +GLenum API_ENTRY(glCheckFramebufferStatus)(GLenum target) { + CALL_GL_API_RETURN(glCheckFramebufferStatus, target); +} +void API_ENTRY(glClear)(GLbitfield mask) { + CALL_GL_API(glClear, mask); +} +void API_ENTRY(glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + CALL_GL_API(glClearColor, red, green, blue, alpha); +} +void API_ENTRY(glClearDepthf)(GLclampf depth) { + CALL_GL_API(glClearDepthf, depth); +} +void API_ENTRY(glClearStencil)(GLint s) { + CALL_GL_API(glClearStencil, s); +} +void API_ENTRY(glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { + CALL_GL_API(glColorMask, red, green, blue, alpha); +} +void API_ENTRY(glCompileShader)(GLuint shader) { + CALL_GL_API(glCompileShader, shader); +} +void API_ENTRY(glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { + CALL_GL_API(glCompressedTexImage2D, target, level, internalformat, width, height, border, imageSize, data); +} +void API_ENTRY(glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { + CALL_GL_API(glCompressedTexSubImage2D, target, level, xoffset, yoffset, width, height, format, imageSize, data); +} +void API_ENTRY(glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { + CALL_GL_API(glCopyTexImage2D, target, level, internalformat, x, y, width, height, border); +} +void API_ENTRY(glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + CALL_GL_API(glCopyTexSubImage2D, target, level, xoffset, yoffset, x, y, width, height); +} +GLuint API_ENTRY(glCreateProgram)(void) { + CALL_GL_API_RETURN(glCreateProgram); +} +GLuint API_ENTRY(glCreateShader)(GLenum type) { + CALL_GL_API_RETURN(glCreateShader, type); +} +void API_ENTRY(glCullFace)(GLenum mode) { + CALL_GL_API(glCullFace, mode); +} +void API_ENTRY(glDeleteBuffers)(GLsizei n, const GLuint:n:in buffers) { + CALL_GL_API(glDeleteBuffers, n, buffers); +} +void API_ENTRY(glDeleteFramebuffers)(GLsizei n, const GLuint:n:in framebuffers) { + CALL_GL_API(glDeleteFramebuffers, n, framebuffers); +} +void API_ENTRY(glDeleteProgram)(GLuint program) { + CALL_GL_API(glDeleteProgram, program); +} +void API_ENTRY(glDeleteRenderbuffers)(GLsizei n, const GLuint:n:in renderbuffers) { + CALL_GL_API(glDeleteRenderbuffers, n, renderbuffers); +} +void API_ENTRY(glDeleteShader)(GLuint shader) { + CALL_GL_API(glDeleteShader, shader); +} +void API_ENTRY(glDeleteTextures)(GLsizei n, const GLuint:n:in textures) { + CALL_GL_API(glDeleteTextures, n, textures); +} +void API_ENTRY(glDepthFunc)(GLenum func) { + CALL_GL_API(glDepthFunc, func); +} +void API_ENTRY(glDepthMask)(GLboolean flag) { + CALL_GL_API(glDepthMask, flag); +} +void API_ENTRY(glDepthRangef)(GLclampf zNear, GLclampf zFar) { + CALL_GL_API(glDepthRangef, zNear, zFar); +} +void API_ENTRY(glDetachShader)(GLuint program, GLuint shader) { + CALL_GL_API(glDetachShader, program, shader); +} +void API_ENTRY(glDisable)(GLenum cap) { + CALL_GL_API(glDisable, cap); +} +void API_ENTRY(glDisableVertexAttribArray)(GLuint index) { + CALL_GL_API(glDisableVertexAttribArray, index); +} +void API_ENTRY(glDrawArrays)(GLenum mode, GLint first, GLsizei count) { + CALL_GL_API(glDrawArrays, mode, first, count); +} +void API_ENTRY(glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { + CALL_GL_API(glDrawElements, mode, count, type, indices); +} +void API_ENTRY(glEnable)(GLenum cap) { + CALL_GL_API(glEnable, cap); +} +void API_ENTRY(glEnableVertexAttribArray)(GLuint index) { + CALL_GL_API(glEnableVertexAttribArray, index); +} +void API_ENTRY(glFinish)(void) { + CALL_GL_API(glFinish); +} +void API_ENTRY(glFlush)(void) { + CALL_GL_API(glFlush); +} +void API_ENTRY(glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { + CALL_GL_API(glFramebufferRenderbuffer, target, attachment, renderbuffertarget, renderbuffer); +} +void API_ENTRY(glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { + CALL_GL_API(glFramebufferTexture2D, target, attachment, textarget, texture, level); +} +void API_ENTRY(glFrontFace)(GLenum mode) { + CALL_GL_API(glFrontFace, mode); +} +void API_ENTRY(glGenBuffers)(GLsizei n, GLuint:n:out buffers) { + CALL_GL_API(glGenBuffers, n, buffers); +} +void API_ENTRY(glGenerateMipmap)(GLenum target) { + CALL_GL_API(glGenerateMipmap, target); +} +void API_ENTRY(glGenFramebuffers)(GLsizei n, GLuint:n:out framebuffers) { + CALL_GL_API(glGenFramebuffers, n, framebuffers); +} +void API_ENTRY(glGenRenderbuffers)(GLsizei n, GLuint:n:out renderbuffers) { + CALL_GL_API(glGenRenderbuffers, n, renderbuffers); +} +void API_ENTRY(glGenTextures)(GLsizei n, GLuint:n:out textures) { + CALL_GL_API(glGenTextures, n, textures); +} +void API_ENTRY(glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar:GLstring:in name) { + CALL_GL_API(glGetActiveAttrib, program, index, bufsize, length, size, type, name); +} +void API_ENTRY(glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar:GLstring:in name) { + CALL_GL_API(glGetActiveUniform, program, index, bufsize, length, size, type, name); +} +void API_ENTRY(glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { + CALL_GL_API(glGetAttachedShaders, program, maxcount, count, shaders); +} +int API_ENTRY(glGetAttribLocation)(GLuint program, const GLchar:GLstring:in name) { + CALL_GL_API_RETURN(glGetAttribLocation, program, name); +} +void API_ENTRY(glGetBooleanv)(GLenum pname, GLboolean* params) { + CALL_GL_API(glGetBooleanv, pname, params); +} +void API_ENTRY(glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params) { + CALL_GL_API(glGetBufferParameteriv, target, pname, params); +} +GLenum API_ENTRY(glGetError)(void) { + CALL_GL_API_RETURN(glGetError); +} +void API_ENTRY(glGetFloatv)(GLenum pname, GLfloat* params) { + CALL_GL_API(glGetFloatv, pname, params); +} +void API_ENTRY(glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params) { + CALL_GL_API(glGetFramebufferAttachmentParameteriv, target, attachment, pname, params); +} +void API_ENTRY(glGetIntegerv)(GLenum pname, GLint* params) { + CALL_GL_API(glGetIntegerv, pname, params); +} +void API_ENTRY(glGetProgramiv)(GLuint program, GLenum pname, GLint:1:out params) { + CALL_GL_API(glGetProgramiv, program, pname, params); +} +void API_ENTRY(glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, GLchar:GLstring:out infolog) { + CALL_GL_API(glGetProgramInfoLog, program, bufsize, length, infolog); +} +void API_ENTRY(glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params) { + CALL_GL_API(glGetRenderbufferParameteriv, target, pname, params); +} +void API_ENTRY(glGetShaderiv)(GLuint shader, GLenum pname, GLint:1:out params) { + CALL_GL_API(glGetShaderiv, shader, pname, params); +} +void API_ENTRY(glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar:GLstring:out infolog) { + CALL_GL_API(glGetShaderInfoLog, shader, bufsize, length, infolog); +} +void API_ENTRY(glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { + CALL_GL_API(glGetShaderPrecisionFormat, shadertype, precisiontype, range, precision); +} +void API_ENTRY(glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar:GLstring:out source) { + CALL_GL_API(glGetShaderSource, shader, bufsize, length, source); +} +const GLubyte* API_ENTRY(glGetString)(GLenum name) { + CALL_GL_API_RETURN(glGetString, name); +} +void API_ENTRY(glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params) { + CALL_GL_API(glGetTexParameterfv, target, pname, params); +} +void API_ENTRY(glGetTexParameteriv)(GLenum target, GLenum pname, GLint* params) { + CALL_GL_API(glGetTexParameteriv, target, pname, params); +} +void API_ENTRY(glGetUniformfv)(GLuint program, GLint location, GLfloat* params) { + CALL_GL_API(glGetUniformfv, program, location, params); +} +void API_ENTRY(glGetUniformiv)(GLuint program, GLint location, GLint* params) { + CALL_GL_API(glGetUniformiv, program, location, params); +} +int API_ENTRY(glGetUniformLocation)(GLuint program, const GLchar:GLstring:in name) { + CALL_GL_API_RETURN(glGetUniformLocation, program, name); +} +void API_ENTRY(glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params) { + CALL_GL_API(glGetVertexAttribfv, index, pname, params); +} +void API_ENTRY(glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params) { + CALL_GL_API(glGetVertexAttribiv, index, pname, params); +} +void API_ENTRY(glGetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid** pointer) { + CALL_GL_API(glGetVertexAttribPointerv, index, pname, pointer); +} +void API_ENTRY(glHint)(GLenum target, GLenum mode) { + CALL_GL_API(glHint, target, mode); +} +GLboolean API_ENTRY(glIsBuffer)(GLuint buffer) { + CALL_GL_API_RETURN(glIsBuffer, buffer); +} +GLboolean API_ENTRY(glIsEnabled)(GLenum cap) { + CALL_GL_API_RETURN(glIsEnabled, cap); +} +GLboolean API_ENTRY(glIsFramebuffer)(GLuint framebuffer) { + CALL_GL_API_RETURN(glIsFramebuffer, framebuffer); +} +GLboolean API_ENTRY(glIsProgram)(GLuint program) { + CALL_GL_API_RETURN(glIsProgram, program); +} +GLboolean API_ENTRY(glIsRenderbuffer)(GLuint renderbuffer) { + CALL_GL_API_RETURN(glIsRenderbuffer, renderbuffer); +} +GLboolean API_ENTRY(glIsShader)(GLuint shader) { + CALL_GL_API_RETURN(glIsShader, shader); +} +GLboolean API_ENTRY(glIsTexture)(GLuint texture) { + CALL_GL_API_RETURN(glIsTexture, texture); +} +void API_ENTRY(glLineWidth)(GLfloat width) { + CALL_GL_API(glLineWidth, width); +} +void API_ENTRY(glLinkProgram)(GLuint program) { + CALL_GL_API(glLinkProgram, program); +} +void API_ENTRY(glPixelStorei)(GLenum pname, GLint param) { + CALL_GL_API(glPixelStorei, pname, param); +} +void API_ENTRY(glPolygonOffset)(GLfloat factor, GLfloat units) { + CALL_GL_API(glPolygonOffset, factor, units); +} +void API_ENTRY(glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { + CALL_GL_API(glReadPixels, x, y, width, height, format, type, pixels); +} +void API_ENTRY(glReleaseShaderCompiler)(void) { + CALL_GL_API(glReleaseShaderCompiler); +} +void API_ENTRY(glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + CALL_GL_API(glRenderbufferStorage, target, internalformat, width, height); +} +void API_ENTRY(glSampleCoverage)(GLclampf value, GLboolean invert) { + CALL_GL_API(glSampleCoverage, value, invert); +} +void API_ENTRY(glScissor)(GLint x, GLint y, GLsizei width, GLsizei height) { + CALL_GL_API(glScissor, x, y, width, height); +} +void API_ENTRY(glShaderBinary)(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) { + CALL_GL_API(glShaderBinary, n, shaders, binaryformat, binary, length); +} +void API_ENTRY(glShaderSource)(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) { + CALL_GL_API(glShaderSource, shader, count, string, length); +} +void API_ENTRY(glStencilFunc)(GLenum func, GLint ref, GLuint mask) { + CALL_GL_API(glStencilFunc, func, ref, mask); +} +void API_ENTRY(glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) { + CALL_GL_API(glStencilFuncSeparate, face, func, ref, mask); +} +void API_ENTRY(glStencilMask)(GLuint mask) { + CALL_GL_API(glStencilMask, mask); +} +void API_ENTRY(glStencilMaskSeparate)(GLenum face, GLuint mask) { + CALL_GL_API(glStencilMaskSeparate, face, mask); +} +void API_ENTRY(glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) { + CALL_GL_API(glStencilOp, fail, zfail, zpass); +} +void API_ENTRY(glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { + CALL_GL_API(glStencilOpSeparate, face, fail, zfail, zpass); +} +void API_ENTRY(glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { + CALL_GL_API(glTexImage2D, target, level, internalformat, width, height, border, format, type, pixels); +} +void API_ENTRY(glTexParameterf)(GLenum target, GLenum pname, GLfloat param) { + CALL_GL_API(glTexParameterf, target, pname, param); +} +void API_ENTRY(glTexParameterfv)(GLenum target, GLenum pname, const GLfloat* params) { + CALL_GL_API(glTexParameterfv, target, pname, params); +} +void API_ENTRY(glTexParameteri)(GLenum target, GLenum pname, GLint param) { + CALL_GL_API(glTexParameteri, target, pname, param); +} +void API_ENTRY(glTexParameteriv)(GLenum target, GLenum pname, const GLint* params) { + CALL_GL_API(glTexParameteriv, target, pname, params); +} +void API_ENTRY(glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { + CALL_GL_API(glTexSubImage2D, target, level, xoffset, yoffset, width, height, format, type, pixels); +} +void API_ENTRY(glUniform1f)(GLint location, GLfloat x) { + CALL_GL_API(glUniform1f, location, x); +} +void API_ENTRY(glUniform1fv)(GLint location, GLsizei count, const GLfloat:1*count:in v) { + CALL_GL_API(glUniform1fv, location, count, v); +} +void API_ENTRY(glUniform1i)(GLint location, GLint x) { + CALL_GL_API(glUniform1i, location, x); +} +void API_ENTRY(glUniform1iv)(GLint location, GLsizei count, const GLint:1*count:in v) { + CALL_GL_API(glUniform1iv, location, count, v); +} +void API_ENTRY(glUniform2f)(GLint location, GLfloat x, GLfloat y) { + CALL_GL_API(glUniform2f, location, x, y); +} +void API_ENTRY(glUniform2fv)(GLint location, GLsizei count, const GLfloat:2*count:in v) { + CALL_GL_API(glUniform2fv, location, count, v); +} +void API_ENTRY(glUniform2i)(GLint location, GLint x, GLint y) { + CALL_GL_API(glUniform2i, location, x, y); +} +void API_ENTRY(glUniform2iv)(GLint location, GLsizei count, const GLint:2*count:in v) { + CALL_GL_API(glUniform2iv, location, count, v); +} +void API_ENTRY(glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z) { + CALL_GL_API(glUniform3f, location, x, y, z); +} +void API_ENTRY(glUniform3fv)(GLint location, GLsizei count, const GLfloat:3*count:in v) { + CALL_GL_API(glUniform3fv, location, count, v); +} +void API_ENTRY(glUniform3i)(GLint location, GLint x, GLint y, GLint z) { + CALL_GL_API(glUniform3i, location, x, y, z); +} +void API_ENTRY(glUniform3iv)(GLint location, GLsizei count, const GLint:3*count:in v) { + CALL_GL_API(glUniform3iv, location, count, v); +} +void API_ENTRY(glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + CALL_GL_API(glUniform4f, location, x, y, z, w); +} +void API_ENTRY(glUniform4fv)(GLint location, GLsizei count, const GLfloat:4*count:in v) { + CALL_GL_API(glUniform4fv, location, count, v); +} +void API_ENTRY(glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w) { + CALL_GL_API(glUniform4i, location, x, y, z, w); +} +void API_ENTRY(glUniform4iv)(GLint location, GLsizei count, const GLint:4*count:in v) { + CALL_GL_API(glUniform4iv, location, count, v); +} +void API_ENTRY(glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat:4*count:in value) { + CALL_GL_API(glUniformMatrix2fv, location, count, transpose, value); +} +void API_ENTRY(glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat:9*count:in value) { + CALL_GL_API(glUniformMatrix3fv, location, count, transpose, value); +} +void API_ENTRY(glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat:16*count:in value) { + CALL_GL_API(glUniformMatrix4fv, location, count, transpose, value); +} +void API_ENTRY(glUseProgram)(GLuint program) { + CALL_GL_API(glUseProgram, program); +} +void API_ENTRY(glValidateProgram)(GLuint program) { + CALL_GL_API(glValidateProgram, program); +} +void API_ENTRY(glVertexAttrib1f)(GLuint indx, GLfloat x) { + CALL_GL_API(glVertexAttrib1f, indx, x); +} +void API_ENTRY(glVertexAttrib1fv)(GLuint indx, const GLfloat:1:in values) { + CALL_GL_API(glVertexAttrib1fv, indx, values); +} +void API_ENTRY(glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y) { + CALL_GL_API(glVertexAttrib2f, indx, x, y); +} +void API_ENTRY(glVertexAttrib2fv)(GLuint indx, const GLfloat:2:in values) { + CALL_GL_API(glVertexAttrib2fv, indx, values); +} +void API_ENTRY(glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { + CALL_GL_API(glVertexAttrib3f, indx, x, y, z); +} +void API_ENTRY(glVertexAttrib3fv)(GLuint indx, const GLfloat:3:in values) { + CALL_GL_API(glVertexAttrib3fv, indx, values); +} +void API_ENTRY(glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + CALL_GL_API(glVertexAttrib4f, indx, x, y, z, w); +} +void API_ENTRY(glVertexAttrib4fv)(GLuint indx, const GLfloat:4:in values) { + CALL_GL_API(glVertexAttrib4fv, indx, values); +} +void API_ENTRY(glVertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) { + CALL_GL_API(glVertexAttribPointer, indx, size, type, normalized, stride, ptr); +} +void API_ENTRY(glViewport)(GLint x, GLint y, GLsizei width, GLsizei height) { + CALL_GL_API(glViewport, x, y, width, height); +} 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); diff --git a/opengl/libs/GLES2_dbg/src/api.h b/opengl/libs/GLES2_dbg/src/api.h new file mode 100644 index 0000000..be94dfc --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/api.h @@ -0,0 +1,31 @@ +/* + ** 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. + */ + +#define EXTEND_Debug_glCopyTexImage2D \ + void * pixels = malloc(width * height * 4); \ + getGLTraceThreadSpecific()->gl.glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); \ + msg.set_data(pixels, width * height * 4); \ + free(pixels); + +#define EXTEND_Debug_glCopyTexSubImage2D EXTEND_Debug_glCopyTexImage2D + +#define EXTEND_Debug_glShaderSource \ + std::string * const data = msg.mutable_data(); \ + for (unsigned i = 0; i < count; i++) \ + if (!length || length[i] < 0) \ + data->append(string[i]); \ + else \ + data->append(string[i], length[i]);
\ No newline at end of file diff --git a/opengl/libs/GLES2_dbg/src/caller.h b/opengl/libs/GLES2_dbg/src/caller.h new file mode 100644 index 0000000..01bc4ea --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/caller.h @@ -0,0 +1,19 @@ +/* + ** 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. + */ + +#include "src/header.h" + + diff --git a/opengl/libs/GLES2_dbg/src/dbgcontext.cpp b/opengl/libs/GLES2_dbg/src/dbgcontext.cpp new file mode 100644 index 0000000..68514df --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/dbgcontext.cpp @@ -0,0 +1,243 @@ +/* + ** 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. + */ + +#include "header.h" + +namespace android +{ + +DbgContext::DbgContext(const unsigned version, const gl_hooks_t * const hooks, + const unsigned MAX_VERTEX_ATTRIBS) + : version(version), hooks(hooks) + , MAX_VERTEX_ATTRIBS(MAX_VERTEX_ATTRIBS) + , vertexAttribs(new VertexAttrib[MAX_VERTEX_ATTRIBS]) + , hasNonVBOAttribs(false), indexBuffers(NULL), indexBuffer(NULL) +{ + for (unsigned i = 0; i < MAX_VERTEX_ATTRIBS; i++) + vertexAttribs[i] = VertexAttrib(); +} + +DbgContext::~DbgContext() +{ + delete vertexAttribs; +} + +DbgContext * CreateDbgContext(const unsigned version, const gl_hooks_t * const hooks) +{ + assert(version < 2); + assert(GL_NO_ERROR == hooks->gl.glGetError()); + GLint MAX_VERTEX_ATTRIBS = 0; + hooks->gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &MAX_VERTEX_ATTRIBS); + return new DbgContext(version, hooks, MAX_VERTEX_ATTRIBS); +} + +void DestroyDbgContext(DbgContext * const dbg) +{ + delete dbg; +} + +void DbgContext::Fetch(const unsigned index, std::string * const data) const +{ + // VBO data is already on client, just send user pointer data + for (unsigned i = 0; i < maxAttrib; i++) { + if (!vertexAttribs[i].enabled) + continue; + if (vertexAttribs[i].buffer > 0) + continue; + const char * ptr = (const char *)vertexAttribs[i].ptr; + ptr += index * vertexAttribs[i].stride; + data->append(ptr, vertexAttribs[i].elemSize); + } +} + +void DbgContext::glUseProgram(GLuint program) +{ + assert(GL_NO_ERROR == hooks->gl.glGetError()); + + this->program = program; + + GLint activeAttributes = 0; + hooks->gl.glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttributes); + maxAttrib = 0; + GLint maxNameLen = -1; + hooks->gl.glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLen); + char * name = new char [maxNameLen + 1]; + name[maxNameLen] = 0; + // find total number of attribute slots used + for (unsigned i = 0; i < activeAttributes; i++) { + GLint size = -1; + GLenum type = -1; + hooks->gl.glGetActiveAttrib(program, i, maxNameLen + 1, NULL, &size, &type, name); + GLint slot = hooks->gl.glGetAttribLocation(program, name); + assert(slot >= 0); + switch (type) { + case GL_FLOAT: + case GL_FLOAT_VEC2: + case GL_FLOAT_VEC3: + case GL_FLOAT_VEC4: + slot += size; + break; + case GL_FLOAT_MAT2: + slot += size * 2; + break; + case GL_FLOAT_MAT3: + slot += size * 3; + break; + case GL_FLOAT_MAT4: + slot += size * 4; + break; + default: + assert(0); + } + if (slot > maxAttrib) + maxAttrib = slot; + } + delete name; +} + +static bool HasNonVBOAttribs(const DbgContext * const ctx) +{ + bool need = false; + for (unsigned i = 0; !need && i < ctx->maxAttrib; i++) + if (ctx->vertexAttribs[i].enabled && ctx->vertexAttribs[i].buffer == 0) + need = true; + return need; +} + +void DbgContext::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, + GLboolean normalized, GLsizei stride, const GLvoid* ptr) +{ + assert(GL_NO_ERROR == hooks->gl.glGetError()); + assert(indx < MAX_VERTEX_ATTRIBS); + vertexAttribs[indx].size = size; + vertexAttribs[indx].type = type; + vertexAttribs[indx].normalized = normalized; + switch (type) { + case GL_FLOAT: + vertexAttribs[indx].elemSize = sizeof(GLfloat) * size; + break; + case GL_INT: + case GL_UNSIGNED_INT: + vertexAttribs[indx].elemSize = sizeof(GLint) * size; + break; + case GL_SHORT: + case GL_UNSIGNED_SHORT: + vertexAttribs[indx].elemSize = sizeof(GLshort) * size; + break; + case GL_BYTE: + case GL_UNSIGNED_BYTE: + vertexAttribs[indx].elemSize = sizeof(GLbyte) * size; + break; + default: + assert(0); + } + if (0 == stride) + stride = vertexAttribs[indx].elemSize; + vertexAttribs[indx].stride = stride; + vertexAttribs[indx].ptr = ptr; + hooks->gl.glGetVertexAttribiv(indx, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, + (GLint *)&vertexAttribs[indx].buffer); + hasNonVBOAttribs = HasNonVBOAttribs(this); +} + +void DbgContext::glEnableVertexAttribArray(GLuint index) +{ + assert(index < MAX_VERTEX_ATTRIBS); + vertexAttribs[index].enabled = true; + hasNonVBOAttribs = HasNonVBOAttribs(this); +} + +void DbgContext::glDisableVertexAttribArray(GLuint index) +{ + assert(index < MAX_VERTEX_ATTRIBS); + vertexAttribs[index].enabled = false; + hasNonVBOAttribs = HasNonVBOAttribs(this); +} + +void DbgContext::glBindBuffer(GLenum target, GLuint buffer) +{ + if (GL_ELEMENT_ARRAY_BUFFER != target) + return; + if (0 == buffer) { + indexBuffer = NULL; + return; + } + VBO * b = indexBuffers; + indexBuffer = NULL; + while (b) { + if (b->name == buffer) { + assert(GL_ELEMENT_ARRAY_BUFFER == b->target); + indexBuffer = b; + break; + } + b = b->next; + } + if (!indexBuffer) + indexBuffer = indexBuffers = new VBO(buffer, target, indexBuffers); +} + +void DbgContext::glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + if (GL_ELEMENT_ARRAY_BUFFER != target) + return; + assert(indexBuffer); + assert(size >= 0); + indexBuffer->size = size; + indexBuffer->data = realloc(indexBuffer->data, size); + memcpy(indexBuffer->data, data, size); +} + +void DbgContext::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + if (GL_ELEMENT_ARRAY_BUFFER != target) + return; + assert(indexBuffer); + assert(size >= 0); + assert(offset >= 0); + assert(offset + size <= indexBuffer->size); + memcpy((char *)indexBuffer->data + offset, data, size); +} + +void DbgContext::glDeleteBuffers(GLsizei n, const GLuint *buffers) +{ + for (unsigned i = 0; i < n; i++) { + for (unsigned j = 0; j < MAX_VERTEX_ATTRIBS; j++) + if (buffers[i] == vertexAttribs[j].buffer) { + vertexAttribs[j].buffer = 0; + vertexAttribs[j].enabled = false; + } + VBO * b = indexBuffers, * previous = NULL; + while (b) { + if (b->name == buffers[i]) { + assert(GL_ELEMENT_ARRAY_BUFFER == b->target); + if (indexBuffer == b) + indexBuffer = NULL; + if (previous) + previous->next = b->next; + else + indexBuffers = b->next; + free(b->data); + delete b; + break; + } + previous = b; + b = b->next; + } + } + hasNonVBOAttribs = HasNonVBOAttribs(this); +} + +}; // namespace android diff --git a/opengl/libs/GLES2_dbg/src/debugger_message.pb.cpp b/opengl/libs/GLES2_dbg/src/debugger_message.pb.cpp new file mode 100644 index 0000000..4083c44 --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/debugger_message.pb.cpp @@ -0,0 +1,1252 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "debugger_message.pb.h" +#include <google/protobuf/stubs/once.h> +#include <google/protobuf/io/coded_stream.h> +#include <google/protobuf/wire_format_lite_inl.h> +// @@protoc_insertion_point(includes) + +namespace com { +namespace android { +namespace glesv2debugger { + +void protobuf_ShutdownFile_debugger_5fmessage_2eproto() { + delete Message::default_instance_; +} + +void protobuf_AddDesc_debugger_5fmessage_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + Message::default_instance_ = new Message(); + Message::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_debugger_5fmessage_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_debugger_5fmessage_2eproto { + StaticDescriptorInitializer_debugger_5fmessage_2eproto() { + protobuf_AddDesc_debugger_5fmessage_2eproto(); + } +} static_descriptor_initializer_debugger_5fmessage_2eproto_; + + +// =================================================================== + +bool Message_Function_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 41: + case 42: + case 43: + case 44: + case 45: + case 46: + case 47: + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + case 96: + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + case 123: + case 124: + case 125: + case 126: + case 127: + case 128: + case 129: + case 130: + case 131: + case 132: + case 133: + case 134: + case 135: + case 136: + case 137: + case 138: + case 139: + case 140: + case 141: + case 142: + case 143: + case 144: + case 145: + case 146: + case 147: + case 148: + case 149: + case 150: + case 151: + case 152: + case 153: + case 154: + case 155: + case 156: + case 157: + case 158: + case 159: + case 160: + case 161: + case 162: + case 163: + case 164: + case 165: + case 166: + case 167: + case 168: + case 169: + case 170: + case 171: + case 172: + case 173: + case 174: + case 175: + case 176: + case 177: + case 178: + case 179: + case 180: + case 181: + case 182: + case 183: + case 184: + case 185: + case 186: + case 187: + case 188: + case 189: + case 190: + case 191: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const Message_Function Message::glActiveTexture; +const Message_Function Message::glAttachShader; +const Message_Function Message::glBindAttribLocation; +const Message_Function Message::glBindBuffer; +const Message_Function Message::glBindFramebuffer; +const Message_Function Message::glBindRenderbuffer; +const Message_Function Message::glBindTexture; +const Message_Function Message::glBlendColor; +const Message_Function Message::glBlendEquation; +const Message_Function Message::glBlendEquationSeparate; +const Message_Function Message::glBlendFunc; +const Message_Function Message::glBlendFuncSeparate; +const Message_Function Message::glBufferData; +const Message_Function Message::glBufferSubData; +const Message_Function Message::glCheckFramebufferStatus; +const Message_Function Message::glClear; +const Message_Function Message::glClearColor; +const Message_Function Message::glClearDepthf; +const Message_Function Message::glClearStencil; +const Message_Function Message::glColorMask; +const Message_Function Message::glCompileShader; +const Message_Function Message::glCompressedTexImage2D; +const Message_Function Message::glCompressedTexSubImage2D; +const Message_Function Message::glCopyTexImage2D; +const Message_Function Message::glCopyTexSubImage2D; +const Message_Function Message::glCreateProgram; +const Message_Function Message::glCreateShader; +const Message_Function Message::glCullFace; +const Message_Function Message::glDeleteBuffers; +const Message_Function Message::glDeleteFramebuffers; +const Message_Function Message::glDeleteProgram; +const Message_Function Message::glDeleteRenderbuffers; +const Message_Function Message::glDeleteShader; +const Message_Function Message::glDeleteTextures; +const Message_Function Message::glDepthFunc; +const Message_Function Message::glDepthMask; +const Message_Function Message::glDepthRangef; +const Message_Function Message::glDetachShader; +const Message_Function Message::glDisable; +const Message_Function Message::glDisableVertexAttribArray; +const Message_Function Message::glDrawArrays; +const Message_Function Message::glDrawElements; +const Message_Function Message::glEnable; +const Message_Function Message::glEnableVertexAttribArray; +const Message_Function Message::glFinish; +const Message_Function Message::glFlush; +const Message_Function Message::glFramebufferRenderbuffer; +const Message_Function Message::glFramebufferTexture2D; +const Message_Function Message::glFrontFace; +const Message_Function Message::glGenBuffers; +const Message_Function Message::glGenerateMipmap; +const Message_Function Message::glGenFramebuffers; +const Message_Function Message::glGenRenderbuffers; +const Message_Function Message::glGenTextures; +const Message_Function Message::glGetActiveAttrib; +const Message_Function Message::glGetActiveUniform; +const Message_Function Message::glGetAttachedShaders; +const Message_Function Message::glGetAttribLocation; +const Message_Function Message::glGetBooleanv; +const Message_Function Message::glGetBufferParameteriv; +const Message_Function Message::glGetError; +const Message_Function Message::glGetFloatv; +const Message_Function Message::glGetFramebufferAttachmentParameteriv; +const Message_Function Message::glGetIntegerv; +const Message_Function Message::glGetProgramiv; +const Message_Function Message::glGetProgramInfoLog; +const Message_Function Message::glGetRenderbufferParameteriv; +const Message_Function Message::glGetShaderiv; +const Message_Function Message::glGetShaderInfoLog; +const Message_Function Message::glGetShaderPrecisionFormat; +const Message_Function Message::glGetShaderSource; +const Message_Function Message::glGetString; +const Message_Function Message::glGetTexParameterfv; +const Message_Function Message::glGetTexParameteriv; +const Message_Function Message::glGetUniformfv; +const Message_Function Message::glGetUniformiv; +const Message_Function Message::glGetUniformLocation; +const Message_Function Message::glGetVertexAttribfv; +const Message_Function Message::glGetVertexAttribiv; +const Message_Function Message::glGetVertexAttribPointerv; +const Message_Function Message::glHint; +const Message_Function Message::glIsBuffer; +const Message_Function Message::glIsEnabled; +const Message_Function Message::glIsFramebuffer; +const Message_Function Message::glIsProgram; +const Message_Function Message::glIsRenderbuffer; +const Message_Function Message::glIsShader; +const Message_Function Message::glIsTexture; +const Message_Function Message::glLineWidth; +const Message_Function Message::glLinkProgram; +const Message_Function Message::glPixelStorei; +const Message_Function Message::glPolygonOffset; +const Message_Function Message::glReadPixels; +const Message_Function Message::glReleaseShaderCompiler; +const Message_Function Message::glRenderbufferStorage; +const Message_Function Message::glSampleCoverage; +const Message_Function Message::glScissor; +const Message_Function Message::glShaderBinary; +const Message_Function Message::glShaderSource; +const Message_Function Message::glStencilFunc; +const Message_Function Message::glStencilFuncSeparate; +const Message_Function Message::glStencilMask; +const Message_Function Message::glStencilMaskSeparate; +const Message_Function Message::glStencilOp; +const Message_Function Message::glStencilOpSeparate; +const Message_Function Message::glTexImage2D; +const Message_Function Message::glTexParameterf; +const Message_Function Message::glTexParameterfv; +const Message_Function Message::glTexParameteri; +const Message_Function Message::glTexParameteriv; +const Message_Function Message::glTexSubImage2D; +const Message_Function Message::glUniform1f; +const Message_Function Message::glUniform1fv; +const Message_Function Message::glUniform1i; +const Message_Function Message::glUniform1iv; +const Message_Function Message::glUniform2f; +const Message_Function Message::glUniform2fv; +const Message_Function Message::glUniform2i; +const Message_Function Message::glUniform2iv; +const Message_Function Message::glUniform3f; +const Message_Function Message::glUniform3fv; +const Message_Function Message::glUniform3i; +const Message_Function Message::glUniform3iv; +const Message_Function Message::glUniform4f; +const Message_Function Message::glUniform4fv; +const Message_Function Message::glUniform4i; +const Message_Function Message::glUniform4iv; +const Message_Function Message::glUniformMatrix2fv; +const Message_Function Message::glUniformMatrix3fv; +const Message_Function Message::glUniformMatrix4fv; +const Message_Function Message::glUseProgram; +const Message_Function Message::glValidateProgram; +const Message_Function Message::glVertexAttrib1f; +const Message_Function Message::glVertexAttrib1fv; +const Message_Function Message::glVertexAttrib2f; +const Message_Function Message::glVertexAttrib2fv; +const Message_Function Message::glVertexAttrib3f; +const Message_Function Message::glVertexAttrib3fv; +const Message_Function Message::glVertexAttrib4f; +const Message_Function Message::glVertexAttrib4fv; +const Message_Function Message::glVertexAttribPointer; +const Message_Function Message::glViewport; +const Message_Function Message::eglGetDisplay; +const Message_Function Message::eglInitialize; +const Message_Function Message::eglTerminate; +const Message_Function Message::eglGetConfigs; +const Message_Function Message::eglChooseConfig; +const Message_Function Message::eglGetConfigAttrib; +const Message_Function Message::eglCreateWindowSurface; +const Message_Function Message::eglCreatePixmapSurface; +const Message_Function Message::eglCreatePbufferSurface; +const Message_Function Message::eglDestroySurface; +const Message_Function Message::eglQuerySurface; +const Message_Function Message::eglCreateContext; +const Message_Function Message::eglDestroyContext; +const Message_Function Message::eglMakeCurrent; +const Message_Function Message::eglGetCurrentContext; +const Message_Function Message::eglGetCurrentSurface; +const Message_Function Message::eglGetCurrentDisplay; +const Message_Function Message::eglQueryContext; +const Message_Function Message::eglWaitGL; +const Message_Function Message::eglWaitNative; +const Message_Function Message::eglSwapBuffers; +const Message_Function Message::eglCopyBuffers; +const Message_Function Message::eglGetError; +const Message_Function Message::eglQueryString; +const Message_Function Message::eglGetProcAddress; +const Message_Function Message::eglSurfaceAttrib; +const Message_Function Message::eglBindTexImage; +const Message_Function Message::eglReleaseTexImage; +const Message_Function Message::eglSwapInterval; +const Message_Function Message::eglBindAPI; +const Message_Function Message::eglQueryAPI; +const Message_Function Message::eglWaitClient; +const Message_Function Message::eglReleaseThread; +const Message_Function Message::eglCreatePbufferFromClientBuffer; +const Message_Function Message::eglLockSurfaceKHR; +const Message_Function Message::eglUnlockSurfaceKHR; +const Message_Function Message::eglCreateImageKHR; +const Message_Function Message::eglDestroyImageKHR; +const Message_Function Message::eglCreateSyncKHR; +const Message_Function Message::eglDestroySyncKHR; +const Message_Function Message::eglClientWaitSyncKHR; +const Message_Function Message::eglGetSyncAttribKHR; +const Message_Function Message::eglSetSwapRectangleANDROID; +const Message_Function Message::eglGetRenderBufferANDROID; +const Message_Function Message::ACK; +const Message_Function Message::NEG; +const Message_Function Message::CONTINUE; +const Message_Function Message::SKIP; +const Message_Function Message::SETPROP; +const Message_Function Message::CAPTURE; +const Message_Function Message::Function_MIN; +const Message_Function Message::Function_MAX; +const int Message::Function_ARRAYSIZE; +#endif // _MSC_VER +bool Message_Type_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const Message_Type Message::BeforeCall; +const Message_Type Message::AfterCall; +const Message_Type Message::Response; +const Message_Type Message::Type_MIN; +const Message_Type Message::Type_MAX; +const int Message::Type_ARRAYSIZE; +#endif // _MSC_VER +bool Message_Prop_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const Message_Prop Message::Capture; +const Message_Prop Message::TimeMode; +const Message_Prop Message::Prop_MIN; +const Message_Prop Message::Prop_MAX; +const int Message::Prop_ARRAYSIZE; +#endif // _MSC_VER +const ::std::string Message::_default_data_; +#ifndef _MSC_VER +const int Message::kContextIdFieldNumber; +const int Message::kFunctionFieldNumber; +const int Message::kTypeFieldNumber; +const int Message::kExpectResponseFieldNumber; +const int Message::kRetFieldNumber; +const int Message::kArg0FieldNumber; +const int Message::kArg1FieldNumber; +const int Message::kArg2FieldNumber; +const int Message::kArg3FieldNumber; +const int Message::kArg4FieldNumber; +const int Message::kArg5FieldNumber; +const int Message::kArg6FieldNumber; +const int Message::kArg7FieldNumber; +const int Message::kArg8FieldNumber; +const int Message::kDataFieldNumber; +const int Message::kTimeFieldNumber; +const int Message::kPropFieldNumber; +const int Message::kClockFieldNumber; +#endif // !_MSC_VER + +Message::Message() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void Message::InitAsDefaultInstance() { +} + +Message::Message(const Message& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void Message::SharedCtor() { + _cached_size_ = 0; + context_id_ = 0; + function_ = 187; + type_ = 0; + expect_response_ = false; + ret_ = 0; + arg0_ = 0; + arg1_ = 0; + arg2_ = 0; + arg3_ = 0; + arg4_ = 0; + arg5_ = 0; + arg6_ = 0; + arg7_ = 0; + arg8_ = 0; + data_ = const_cast< ::std::string*>(&_default_data_); + time_ = 0; + prop_ = 0; + clock_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Message::~Message() { + SharedDtor(); +} + +void Message::SharedDtor() { + if (data_ != &_default_data_) { + delete data_; + } + if (this != default_instance_) { + } +} + +void Message::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const Message& Message::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_debugger_5fmessage_2eproto(); return *default_instance_; +} + +Message* Message::default_instance_ = NULL; + +Message* Message::New() const { + return new Message; +} + +void Message::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + context_id_ = 0; + function_ = 187; + type_ = 0; + expect_response_ = false; + ret_ = 0; + arg0_ = 0; + arg1_ = 0; + arg2_ = 0; + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + arg3_ = 0; + arg4_ = 0; + arg5_ = 0; + arg6_ = 0; + arg7_ = 0; + arg8_ = 0; + if (_has_bit(14)) { + if (data_ != &_default_data_) { + data_->clear(); + } + } + time_ = 0; + } + if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + prop_ = 0; + clock_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool Message::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int32 context_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &context_id_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_function; + break; + } + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_function: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::com::android::glesv2debugger::Message_Function_IsValid(value)) { + set_function(static_cast< ::com::android::glesv2debugger::Message_Function >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_type; + break; + } + + // required .com.android.glesv2debugger.Message.Type type = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::com::android::glesv2debugger::Message_Type_IsValid(value)) { + set_type(static_cast< ::com::android::glesv2debugger::Message_Type >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_expect_response; + break; + } + + // required bool expect_response = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_expect_response: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &expect_response_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_ret; + break; + } + + // optional int32 ret = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_ret: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &ret_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_arg0; + break; + } + + // optional int32 arg0 = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg0: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg0_))); + _set_bit(5); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_arg1; + break; + } + + // optional int32 arg1 = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg1: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg1_))); + _set_bit(6); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(64)) goto parse_arg2; + break; + } + + // optional int32 arg2 = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg2: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg2_))); + _set_bit(7); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(72)) goto parse_arg3; + break; + } + + // optional int32 arg3 = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg3: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg3_))); + _set_bit(8); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(82)) goto parse_data; + break; + } + + // optional bytes data = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(93)) goto parse_time; + break; + } + + // optional float time = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &time_))); + _set_bit(15); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(128)) goto parse_arg4; + break; + } + + // optional int32 arg4 = 16; + case 16: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg4: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg4_))); + _set_bit(9); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(136)) goto parse_arg5; + break; + } + + // optional int32 arg5 = 17; + case 17: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg5: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg5_))); + _set_bit(10); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(144)) goto parse_arg6; + break; + } + + // optional int32 arg6 = 18; + case 18: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg6: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg6_))); + _set_bit(11); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(152)) goto parse_arg7; + break; + } + + // optional int32 arg7 = 19; + case 19: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg7: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg7_))); + _set_bit(12); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(160)) goto parse_arg8; + break; + } + + // optional int32 arg8 = 20; + case 20: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_arg8: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &arg8_))); + _set_bit(13); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(168)) goto parse_prop; + break; + } + + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + case 21: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_prop: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::com::android::glesv2debugger::Message_Prop_IsValid(value)) { + set_prop(static_cast< ::com::android::glesv2debugger::Message_Prop >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(181)) goto parse_clock; + break; + } + + // optional float clock = 22; + case 22: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_clock: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &clock_))); + _set_bit(17); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void Message::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 context_id = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->context_id(), output); + } + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->function(), output); + } + + // required .com.android.glesv2debugger.Message.Type type = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 3, this->type(), output); + } + + // required bool expect_response = 4; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->expect_response(), output); + } + + // optional int32 ret = 5; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->ret(), output); + } + + // optional int32 arg0 = 6; + if (_has_bit(5)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->arg0(), output); + } + + // optional int32 arg1 = 7; + if (_has_bit(6)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->arg1(), output); + } + + // optional int32 arg2 = 8; + if (_has_bit(7)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->arg2(), output); + } + + // optional int32 arg3 = 9; + if (_has_bit(8)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->arg3(), output); + } + + // optional bytes data = 10; + if (_has_bit(14)) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 10, this->data(), output); + } + + // optional float time = 11; + if (_has_bit(15)) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->time(), output); + } + + // optional int32 arg4 = 16; + if (_has_bit(9)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(16, this->arg4(), output); + } + + // optional int32 arg5 = 17; + if (_has_bit(10)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->arg5(), output); + } + + // optional int32 arg6 = 18; + if (_has_bit(11)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(18, this->arg6(), output); + } + + // optional int32 arg7 = 19; + if (_has_bit(12)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(19, this->arg7(), output); + } + + // optional int32 arg8 = 20; + if (_has_bit(13)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(20, this->arg8(), output); + } + + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + if (_has_bit(16)) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 21, this->prop(), output); + } + + // optional float clock = 22; + if (_has_bit(17)) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(22, this->clock(), output); + } + +} + +int Message::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 context_id = 1; + if (has_context_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->context_id()); + } + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + if (has_function()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->function()); + } + + // required .com.android.glesv2debugger.Message.Type type = 3; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + // required bool expect_response = 4; + if (has_expect_response()) { + total_size += 1 + 1; + } + + // optional int32 ret = 5; + if (has_ret()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->ret()); + } + + // optional int32 arg0 = 6; + if (has_arg0()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg0()); + } + + // optional int32 arg1 = 7; + if (has_arg1()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg1()); + } + + // optional int32 arg2 = 8; + if (has_arg2()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg2()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional int32 arg3 = 9; + if (has_arg3()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg3()); + } + + // optional int32 arg4 = 16; + if (has_arg4()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg4()); + } + + // optional int32 arg5 = 17; + if (has_arg5()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg5()); + } + + // optional int32 arg6 = 18; + if (has_arg6()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg6()); + } + + // optional int32 arg7 = 19; + if (has_arg7()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg7()); + } + + // optional int32 arg8 = 20; + if (has_arg8()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->arg8()); + } + + // optional bytes data = 10; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->data()); + } + + // optional float time = 11; + if (has_time()) { + total_size += 1 + 4; + } + + } + if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + if (has_prop()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->prop()); + } + + // optional float clock = 22; + if (has_clock()) { + total_size += 2 + 4; + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Message::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const Message*>(&from)); +} + +void Message::MergeFrom(const Message& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_context_id(from.context_id()); + } + if (from._has_bit(1)) { + set_function(from.function()); + } + if (from._has_bit(2)) { + set_type(from.type()); + } + if (from._has_bit(3)) { + set_expect_response(from.expect_response()); + } + if (from._has_bit(4)) { + set_ret(from.ret()); + } + if (from._has_bit(5)) { + set_arg0(from.arg0()); + } + if (from._has_bit(6)) { + set_arg1(from.arg1()); + } + if (from._has_bit(7)) { + set_arg2(from.arg2()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from._has_bit(8)) { + set_arg3(from.arg3()); + } + if (from._has_bit(9)) { + set_arg4(from.arg4()); + } + if (from._has_bit(10)) { + set_arg5(from.arg5()); + } + if (from._has_bit(11)) { + set_arg6(from.arg6()); + } + if (from._has_bit(12)) { + set_arg7(from.arg7()); + } + if (from._has_bit(13)) { + set_arg8(from.arg8()); + } + if (from._has_bit(14)) { + set_data(from.data()); + } + if (from._has_bit(15)) { + set_time(from.time()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from._has_bit(16)) { + set_prop(from.prop()); + } + if (from._has_bit(17)) { + set_clock(from.clock()); + } + } +} + +void Message::CopyFrom(const Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + return true; +} + +void Message::Swap(Message* other) { + if (other != this) { + std::swap(context_id_, other->context_id_); + std::swap(function_, other->function_); + std::swap(type_, other->type_); + std::swap(expect_response_, other->expect_response_); + std::swap(ret_, other->ret_); + std::swap(arg0_, other->arg0_); + std::swap(arg1_, other->arg1_); + std::swap(arg2_, other->arg2_); + std::swap(arg3_, other->arg3_); + std::swap(arg4_, other->arg4_); + std::swap(arg5_, other->arg5_); + std::swap(arg6_, other->arg6_); + std::swap(arg7_, other->arg7_); + std::swap(arg8_, other->arg8_); + std::swap(data_, other->data_); + std::swap(time_, other->time_); + std::swap(prop_, other->prop_); + std::swap(clock_, other->clock_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string Message::GetTypeName() const { + return "com.android.glesv2debugger.Message"; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace glesv2debugger +} // namespace android +} // namespace com + +// @@protoc_insertion_point(global_scope) diff --git a/opengl/libs/GLES2_dbg/src/debugger_message.pb.h b/opengl/libs/GLES2_dbg/src/debugger_message.pb.h new file mode 100644 index 0000000..3f2b842 --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/debugger_message.pb.h @@ -0,0 +1,1036 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: debugger_message.proto + +#ifndef PROTOBUF_debugger_5fmessage_2eproto__INCLUDED +#define PROTOBUF_debugger_5fmessage_2eproto__INCLUDED + +#include <string> + +#include <google/protobuf/stubs/common.h> + +#if GOOGLE_PROTOBUF_VERSION < 2003000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include <google/protobuf/generated_message_util.h> +#include <google/protobuf/repeated_field.h> +#include <google/protobuf/extension_set.h> +// @@protoc_insertion_point(includes) + +namespace com { +namespace android { +namespace glesv2debugger { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_debugger_5fmessage_2eproto(); +void protobuf_AssignDesc_debugger_5fmessage_2eproto(); +void protobuf_ShutdownFile_debugger_5fmessage_2eproto(); + +class Message; + +enum Message_Function { + Message_Function_glActiveTexture = 0, + Message_Function_glAttachShader = 1, + Message_Function_glBindAttribLocation = 2, + Message_Function_glBindBuffer = 3, + Message_Function_glBindFramebuffer = 4, + Message_Function_glBindRenderbuffer = 5, + Message_Function_glBindTexture = 6, + Message_Function_glBlendColor = 7, + Message_Function_glBlendEquation = 8, + Message_Function_glBlendEquationSeparate = 9, + Message_Function_glBlendFunc = 10, + Message_Function_glBlendFuncSeparate = 11, + Message_Function_glBufferData = 12, + Message_Function_glBufferSubData = 13, + Message_Function_glCheckFramebufferStatus = 14, + Message_Function_glClear = 15, + Message_Function_glClearColor = 16, + Message_Function_glClearDepthf = 17, + Message_Function_glClearStencil = 18, + Message_Function_glColorMask = 19, + Message_Function_glCompileShader = 20, + Message_Function_glCompressedTexImage2D = 21, + Message_Function_glCompressedTexSubImage2D = 22, + Message_Function_glCopyTexImage2D = 23, + Message_Function_glCopyTexSubImage2D = 24, + Message_Function_glCreateProgram = 25, + Message_Function_glCreateShader = 26, + Message_Function_glCullFace = 27, + Message_Function_glDeleteBuffers = 28, + Message_Function_glDeleteFramebuffers = 29, + Message_Function_glDeleteProgram = 30, + Message_Function_glDeleteRenderbuffers = 31, + Message_Function_glDeleteShader = 32, + Message_Function_glDeleteTextures = 33, + Message_Function_glDepthFunc = 34, + Message_Function_glDepthMask = 35, + Message_Function_glDepthRangef = 36, + Message_Function_glDetachShader = 37, + Message_Function_glDisable = 38, + Message_Function_glDisableVertexAttribArray = 39, + Message_Function_glDrawArrays = 40, + Message_Function_glDrawElements = 41, + Message_Function_glEnable = 42, + Message_Function_glEnableVertexAttribArray = 43, + Message_Function_glFinish = 44, + Message_Function_glFlush = 45, + Message_Function_glFramebufferRenderbuffer = 46, + Message_Function_glFramebufferTexture2D = 47, + Message_Function_glFrontFace = 48, + Message_Function_glGenBuffers = 49, + Message_Function_glGenerateMipmap = 50, + Message_Function_glGenFramebuffers = 51, + Message_Function_glGenRenderbuffers = 52, + Message_Function_glGenTextures = 53, + Message_Function_glGetActiveAttrib = 54, + Message_Function_glGetActiveUniform = 55, + Message_Function_glGetAttachedShaders = 56, + Message_Function_glGetAttribLocation = 57, + Message_Function_glGetBooleanv = 58, + Message_Function_glGetBufferParameteriv = 59, + Message_Function_glGetError = 60, + Message_Function_glGetFloatv = 61, + Message_Function_glGetFramebufferAttachmentParameteriv = 62, + Message_Function_glGetIntegerv = 63, + Message_Function_glGetProgramiv = 64, + Message_Function_glGetProgramInfoLog = 65, + Message_Function_glGetRenderbufferParameteriv = 66, + Message_Function_glGetShaderiv = 67, + Message_Function_glGetShaderInfoLog = 68, + Message_Function_glGetShaderPrecisionFormat = 69, + Message_Function_glGetShaderSource = 70, + Message_Function_glGetString = 71, + Message_Function_glGetTexParameterfv = 72, + Message_Function_glGetTexParameteriv = 73, + Message_Function_glGetUniformfv = 74, + Message_Function_glGetUniformiv = 75, + Message_Function_glGetUniformLocation = 76, + Message_Function_glGetVertexAttribfv = 77, + Message_Function_glGetVertexAttribiv = 78, + Message_Function_glGetVertexAttribPointerv = 79, + Message_Function_glHint = 80, + Message_Function_glIsBuffer = 81, + Message_Function_glIsEnabled = 82, + Message_Function_glIsFramebuffer = 83, + Message_Function_glIsProgram = 84, + Message_Function_glIsRenderbuffer = 85, + Message_Function_glIsShader = 86, + Message_Function_glIsTexture = 87, + Message_Function_glLineWidth = 88, + Message_Function_glLinkProgram = 89, + Message_Function_glPixelStorei = 90, + Message_Function_glPolygonOffset = 91, + Message_Function_glReadPixels = 92, + Message_Function_glReleaseShaderCompiler = 93, + Message_Function_glRenderbufferStorage = 94, + Message_Function_glSampleCoverage = 95, + Message_Function_glScissor = 96, + Message_Function_glShaderBinary = 97, + Message_Function_glShaderSource = 98, + Message_Function_glStencilFunc = 99, + Message_Function_glStencilFuncSeparate = 100, + Message_Function_glStencilMask = 101, + Message_Function_glStencilMaskSeparate = 102, + Message_Function_glStencilOp = 103, + Message_Function_glStencilOpSeparate = 104, + Message_Function_glTexImage2D = 105, + Message_Function_glTexParameterf = 106, + Message_Function_glTexParameterfv = 107, + Message_Function_glTexParameteri = 108, + Message_Function_glTexParameteriv = 109, + Message_Function_glTexSubImage2D = 110, + Message_Function_glUniform1f = 111, + Message_Function_glUniform1fv = 112, + Message_Function_glUniform1i = 113, + Message_Function_glUniform1iv = 114, + Message_Function_glUniform2f = 115, + Message_Function_glUniform2fv = 116, + Message_Function_glUniform2i = 117, + Message_Function_glUniform2iv = 118, + Message_Function_glUniform3f = 119, + Message_Function_glUniform3fv = 120, + Message_Function_glUniform3i = 121, + Message_Function_glUniform3iv = 122, + Message_Function_glUniform4f = 123, + Message_Function_glUniform4fv = 124, + Message_Function_glUniform4i = 125, + Message_Function_glUniform4iv = 126, + Message_Function_glUniformMatrix2fv = 127, + Message_Function_glUniformMatrix3fv = 128, + Message_Function_glUniformMatrix4fv = 129, + Message_Function_glUseProgram = 130, + Message_Function_glValidateProgram = 131, + Message_Function_glVertexAttrib1f = 132, + Message_Function_glVertexAttrib1fv = 133, + Message_Function_glVertexAttrib2f = 134, + Message_Function_glVertexAttrib2fv = 135, + Message_Function_glVertexAttrib3f = 136, + Message_Function_glVertexAttrib3fv = 137, + Message_Function_glVertexAttrib4f = 138, + Message_Function_glVertexAttrib4fv = 139, + Message_Function_glVertexAttribPointer = 140, + Message_Function_glViewport = 141, + Message_Function_eglGetDisplay = 142, + Message_Function_eglInitialize = 143, + Message_Function_eglTerminate = 144, + Message_Function_eglGetConfigs = 145, + Message_Function_eglChooseConfig = 146, + Message_Function_eglGetConfigAttrib = 147, + Message_Function_eglCreateWindowSurface = 148, + Message_Function_eglCreatePixmapSurface = 149, + Message_Function_eglCreatePbufferSurface = 150, + Message_Function_eglDestroySurface = 151, + Message_Function_eglQuerySurface = 152, + Message_Function_eglCreateContext = 153, + Message_Function_eglDestroyContext = 154, + Message_Function_eglMakeCurrent = 155, + Message_Function_eglGetCurrentContext = 156, + Message_Function_eglGetCurrentSurface = 157, + Message_Function_eglGetCurrentDisplay = 158, + Message_Function_eglQueryContext = 159, + Message_Function_eglWaitGL = 160, + Message_Function_eglWaitNative = 161, + Message_Function_eglSwapBuffers = 162, + Message_Function_eglCopyBuffers = 163, + Message_Function_eglGetError = 164, + Message_Function_eglQueryString = 165, + Message_Function_eglGetProcAddress = 166, + Message_Function_eglSurfaceAttrib = 167, + Message_Function_eglBindTexImage = 168, + Message_Function_eglReleaseTexImage = 169, + Message_Function_eglSwapInterval = 170, + Message_Function_eglBindAPI = 171, + Message_Function_eglQueryAPI = 172, + Message_Function_eglWaitClient = 173, + Message_Function_eglReleaseThread = 174, + Message_Function_eglCreatePbufferFromClientBuffer = 175, + Message_Function_eglLockSurfaceKHR = 176, + Message_Function_eglUnlockSurfaceKHR = 177, + Message_Function_eglCreateImageKHR = 178, + Message_Function_eglDestroyImageKHR = 179, + Message_Function_eglCreateSyncKHR = 180, + Message_Function_eglDestroySyncKHR = 181, + Message_Function_eglClientWaitSyncKHR = 182, + Message_Function_eglGetSyncAttribKHR = 183, + Message_Function_eglSetSwapRectangleANDROID = 184, + Message_Function_eglGetRenderBufferANDROID = 185, + Message_Function_ACK = 186, + Message_Function_NEG = 187, + Message_Function_CONTINUE = 188, + Message_Function_SKIP = 189, + Message_Function_SETPROP = 190, + Message_Function_CAPTURE = 191 +}; +bool Message_Function_IsValid(int value); +const Message_Function Message_Function_Function_MIN = Message_Function_glActiveTexture; +const Message_Function Message_Function_Function_MAX = Message_Function_CAPTURE; +const int Message_Function_Function_ARRAYSIZE = Message_Function_Function_MAX + 1; + +enum Message_Type { + Message_Type_BeforeCall = 0, + Message_Type_AfterCall = 1, + Message_Type_Response = 2 +}; +bool Message_Type_IsValid(int value); +const Message_Type Message_Type_Type_MIN = Message_Type_BeforeCall; +const Message_Type Message_Type_Type_MAX = Message_Type_Response; +const int Message_Type_Type_ARRAYSIZE = Message_Type_Type_MAX + 1; + +enum Message_Prop { + Message_Prop_Capture = 0, + Message_Prop_TimeMode = 1 +}; +bool Message_Prop_IsValid(int value); +const Message_Prop Message_Prop_Prop_MIN = Message_Prop_Capture; +const Message_Prop Message_Prop_Prop_MAX = Message_Prop_TimeMode; +const int Message_Prop_Prop_ARRAYSIZE = Message_Prop_Prop_MAX + 1; + +// =================================================================== + +class Message : public ::google::protobuf::MessageLite { + public: + Message(); + virtual ~Message(); + + Message(const Message& from); + + inline Message& operator=(const Message& from) { + CopyFrom(from); + return *this; + } + + static const Message& default_instance(); + + void Swap(Message* other); + + // implements Message ---------------------------------------------- + + Message* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const Message& from); + void MergeFrom(const Message& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef Message_Function Function; + static const Function glActiveTexture = Message_Function_glActiveTexture; + static const Function glAttachShader = Message_Function_glAttachShader; + static const Function glBindAttribLocation = Message_Function_glBindAttribLocation; + static const Function glBindBuffer = Message_Function_glBindBuffer; + static const Function glBindFramebuffer = Message_Function_glBindFramebuffer; + static const Function glBindRenderbuffer = Message_Function_glBindRenderbuffer; + static const Function glBindTexture = Message_Function_glBindTexture; + static const Function glBlendColor = Message_Function_glBlendColor; + static const Function glBlendEquation = Message_Function_glBlendEquation; + static const Function glBlendEquationSeparate = Message_Function_glBlendEquationSeparate; + static const Function glBlendFunc = Message_Function_glBlendFunc; + static const Function glBlendFuncSeparate = Message_Function_glBlendFuncSeparate; + static const Function glBufferData = Message_Function_glBufferData; + static const Function glBufferSubData = Message_Function_glBufferSubData; + static const Function glCheckFramebufferStatus = Message_Function_glCheckFramebufferStatus; + static const Function glClear = Message_Function_glClear; + static const Function glClearColor = Message_Function_glClearColor; + static const Function glClearDepthf = Message_Function_glClearDepthf; + static const Function glClearStencil = Message_Function_glClearStencil; + static const Function glColorMask = Message_Function_glColorMask; + static const Function glCompileShader = Message_Function_glCompileShader; + static const Function glCompressedTexImage2D = Message_Function_glCompressedTexImage2D; + static const Function glCompressedTexSubImage2D = Message_Function_glCompressedTexSubImage2D; + static const Function glCopyTexImage2D = Message_Function_glCopyTexImage2D; + static const Function glCopyTexSubImage2D = Message_Function_glCopyTexSubImage2D; + static const Function glCreateProgram = Message_Function_glCreateProgram; + static const Function glCreateShader = Message_Function_glCreateShader; + static const Function glCullFace = Message_Function_glCullFace; + static const Function glDeleteBuffers = Message_Function_glDeleteBuffers; + static const Function glDeleteFramebuffers = Message_Function_glDeleteFramebuffers; + static const Function glDeleteProgram = Message_Function_glDeleteProgram; + static const Function glDeleteRenderbuffers = Message_Function_glDeleteRenderbuffers; + static const Function glDeleteShader = Message_Function_glDeleteShader; + static const Function glDeleteTextures = Message_Function_glDeleteTextures; + static const Function glDepthFunc = Message_Function_glDepthFunc; + static const Function glDepthMask = Message_Function_glDepthMask; + static const Function glDepthRangef = Message_Function_glDepthRangef; + static const Function glDetachShader = Message_Function_glDetachShader; + static const Function glDisable = Message_Function_glDisable; + static const Function glDisableVertexAttribArray = Message_Function_glDisableVertexAttribArray; + static const Function glDrawArrays = Message_Function_glDrawArrays; + static const Function glDrawElements = Message_Function_glDrawElements; + static const Function glEnable = Message_Function_glEnable; + static const Function glEnableVertexAttribArray = Message_Function_glEnableVertexAttribArray; + static const Function glFinish = Message_Function_glFinish; + static const Function glFlush = Message_Function_glFlush; + static const Function glFramebufferRenderbuffer = Message_Function_glFramebufferRenderbuffer; + static const Function glFramebufferTexture2D = Message_Function_glFramebufferTexture2D; + static const Function glFrontFace = Message_Function_glFrontFace; + static const Function glGenBuffers = Message_Function_glGenBuffers; + static const Function glGenerateMipmap = Message_Function_glGenerateMipmap; + static const Function glGenFramebuffers = Message_Function_glGenFramebuffers; + static const Function glGenRenderbuffers = Message_Function_glGenRenderbuffers; + static const Function glGenTextures = Message_Function_glGenTextures; + static const Function glGetActiveAttrib = Message_Function_glGetActiveAttrib; + static const Function glGetActiveUniform = Message_Function_glGetActiveUniform; + static const Function glGetAttachedShaders = Message_Function_glGetAttachedShaders; + static const Function glGetAttribLocation = Message_Function_glGetAttribLocation; + static const Function glGetBooleanv = Message_Function_glGetBooleanv; + static const Function glGetBufferParameteriv = Message_Function_glGetBufferParameteriv; + static const Function glGetError = Message_Function_glGetError; + static const Function glGetFloatv = Message_Function_glGetFloatv; + static const Function glGetFramebufferAttachmentParameteriv = Message_Function_glGetFramebufferAttachmentParameteriv; + static const Function glGetIntegerv = Message_Function_glGetIntegerv; + static const Function glGetProgramiv = Message_Function_glGetProgramiv; + static const Function glGetProgramInfoLog = Message_Function_glGetProgramInfoLog; + static const Function glGetRenderbufferParameteriv = Message_Function_glGetRenderbufferParameteriv; + static const Function glGetShaderiv = Message_Function_glGetShaderiv; + static const Function glGetShaderInfoLog = Message_Function_glGetShaderInfoLog; + static const Function glGetShaderPrecisionFormat = Message_Function_glGetShaderPrecisionFormat; + static const Function glGetShaderSource = Message_Function_glGetShaderSource; + static const Function glGetString = Message_Function_glGetString; + static const Function glGetTexParameterfv = Message_Function_glGetTexParameterfv; + static const Function glGetTexParameteriv = Message_Function_glGetTexParameteriv; + static const Function glGetUniformfv = Message_Function_glGetUniformfv; + static const Function glGetUniformiv = Message_Function_glGetUniformiv; + static const Function glGetUniformLocation = Message_Function_glGetUniformLocation; + static const Function glGetVertexAttribfv = Message_Function_glGetVertexAttribfv; + static const Function glGetVertexAttribiv = Message_Function_glGetVertexAttribiv; + static const Function glGetVertexAttribPointerv = Message_Function_glGetVertexAttribPointerv; + static const Function glHint = Message_Function_glHint; + static const Function glIsBuffer = Message_Function_glIsBuffer; + static const Function glIsEnabled = Message_Function_glIsEnabled; + static const Function glIsFramebuffer = Message_Function_glIsFramebuffer; + static const Function glIsProgram = Message_Function_glIsProgram; + static const Function glIsRenderbuffer = Message_Function_glIsRenderbuffer; + static const Function glIsShader = Message_Function_glIsShader; + static const Function glIsTexture = Message_Function_glIsTexture; + static const Function glLineWidth = Message_Function_glLineWidth; + static const Function glLinkProgram = Message_Function_glLinkProgram; + static const Function glPixelStorei = Message_Function_glPixelStorei; + static const Function glPolygonOffset = Message_Function_glPolygonOffset; + static const Function glReadPixels = Message_Function_glReadPixels; + static const Function glReleaseShaderCompiler = Message_Function_glReleaseShaderCompiler; + static const Function glRenderbufferStorage = Message_Function_glRenderbufferStorage; + static const Function glSampleCoverage = Message_Function_glSampleCoverage; + static const Function glScissor = Message_Function_glScissor; + static const Function glShaderBinary = Message_Function_glShaderBinary; + static const Function glShaderSource = Message_Function_glShaderSource; + static const Function glStencilFunc = Message_Function_glStencilFunc; + static const Function glStencilFuncSeparate = Message_Function_glStencilFuncSeparate; + static const Function glStencilMask = Message_Function_glStencilMask; + static const Function glStencilMaskSeparate = Message_Function_glStencilMaskSeparate; + static const Function glStencilOp = Message_Function_glStencilOp; + static const Function glStencilOpSeparate = Message_Function_glStencilOpSeparate; + static const Function glTexImage2D = Message_Function_glTexImage2D; + static const Function glTexParameterf = Message_Function_glTexParameterf; + static const Function glTexParameterfv = Message_Function_glTexParameterfv; + static const Function glTexParameteri = Message_Function_glTexParameteri; + static const Function glTexParameteriv = Message_Function_glTexParameteriv; + static const Function glTexSubImage2D = Message_Function_glTexSubImage2D; + static const Function glUniform1f = Message_Function_glUniform1f; + static const Function glUniform1fv = Message_Function_glUniform1fv; + static const Function glUniform1i = Message_Function_glUniform1i; + static const Function glUniform1iv = Message_Function_glUniform1iv; + static const Function glUniform2f = Message_Function_glUniform2f; + static const Function glUniform2fv = Message_Function_glUniform2fv; + static const Function glUniform2i = Message_Function_glUniform2i; + static const Function glUniform2iv = Message_Function_glUniform2iv; + static const Function glUniform3f = Message_Function_glUniform3f; + static const Function glUniform3fv = Message_Function_glUniform3fv; + static const Function glUniform3i = Message_Function_glUniform3i; + static const Function glUniform3iv = Message_Function_glUniform3iv; + static const Function glUniform4f = Message_Function_glUniform4f; + static const Function glUniform4fv = Message_Function_glUniform4fv; + static const Function glUniform4i = Message_Function_glUniform4i; + static const Function glUniform4iv = Message_Function_glUniform4iv; + static const Function glUniformMatrix2fv = Message_Function_glUniformMatrix2fv; + static const Function glUniformMatrix3fv = Message_Function_glUniformMatrix3fv; + static const Function glUniformMatrix4fv = Message_Function_glUniformMatrix4fv; + static const Function glUseProgram = Message_Function_glUseProgram; + static const Function glValidateProgram = Message_Function_glValidateProgram; + static const Function glVertexAttrib1f = Message_Function_glVertexAttrib1f; + static const Function glVertexAttrib1fv = Message_Function_glVertexAttrib1fv; + static const Function glVertexAttrib2f = Message_Function_glVertexAttrib2f; + static const Function glVertexAttrib2fv = Message_Function_glVertexAttrib2fv; + static const Function glVertexAttrib3f = Message_Function_glVertexAttrib3f; + static const Function glVertexAttrib3fv = Message_Function_glVertexAttrib3fv; + static const Function glVertexAttrib4f = Message_Function_glVertexAttrib4f; + static const Function glVertexAttrib4fv = Message_Function_glVertexAttrib4fv; + static const Function glVertexAttribPointer = Message_Function_glVertexAttribPointer; + static const Function glViewport = Message_Function_glViewport; + static const Function eglGetDisplay = Message_Function_eglGetDisplay; + static const Function eglInitialize = Message_Function_eglInitialize; + static const Function eglTerminate = Message_Function_eglTerminate; + static const Function eglGetConfigs = Message_Function_eglGetConfigs; + static const Function eglChooseConfig = Message_Function_eglChooseConfig; + static const Function eglGetConfigAttrib = Message_Function_eglGetConfigAttrib; + static const Function eglCreateWindowSurface = Message_Function_eglCreateWindowSurface; + static const Function eglCreatePixmapSurface = Message_Function_eglCreatePixmapSurface; + static const Function eglCreatePbufferSurface = Message_Function_eglCreatePbufferSurface; + static const Function eglDestroySurface = Message_Function_eglDestroySurface; + static const Function eglQuerySurface = Message_Function_eglQuerySurface; + static const Function eglCreateContext = Message_Function_eglCreateContext; + static const Function eglDestroyContext = Message_Function_eglDestroyContext; + static const Function eglMakeCurrent = Message_Function_eglMakeCurrent; + static const Function eglGetCurrentContext = Message_Function_eglGetCurrentContext; + static const Function eglGetCurrentSurface = Message_Function_eglGetCurrentSurface; + static const Function eglGetCurrentDisplay = Message_Function_eglGetCurrentDisplay; + static const Function eglQueryContext = Message_Function_eglQueryContext; + static const Function eglWaitGL = Message_Function_eglWaitGL; + static const Function eglWaitNative = Message_Function_eglWaitNative; + static const Function eglSwapBuffers = Message_Function_eglSwapBuffers; + static const Function eglCopyBuffers = Message_Function_eglCopyBuffers; + static const Function eglGetError = Message_Function_eglGetError; + static const Function eglQueryString = Message_Function_eglQueryString; + static const Function eglGetProcAddress = Message_Function_eglGetProcAddress; + static const Function eglSurfaceAttrib = Message_Function_eglSurfaceAttrib; + static const Function eglBindTexImage = Message_Function_eglBindTexImage; + static const Function eglReleaseTexImage = Message_Function_eglReleaseTexImage; + static const Function eglSwapInterval = Message_Function_eglSwapInterval; + static const Function eglBindAPI = Message_Function_eglBindAPI; + static const Function eglQueryAPI = Message_Function_eglQueryAPI; + static const Function eglWaitClient = Message_Function_eglWaitClient; + static const Function eglReleaseThread = Message_Function_eglReleaseThread; + static const Function eglCreatePbufferFromClientBuffer = Message_Function_eglCreatePbufferFromClientBuffer; + static const Function eglLockSurfaceKHR = Message_Function_eglLockSurfaceKHR; + static const Function eglUnlockSurfaceKHR = Message_Function_eglUnlockSurfaceKHR; + static const Function eglCreateImageKHR = Message_Function_eglCreateImageKHR; + static const Function eglDestroyImageKHR = Message_Function_eglDestroyImageKHR; + static const Function eglCreateSyncKHR = Message_Function_eglCreateSyncKHR; + static const Function eglDestroySyncKHR = Message_Function_eglDestroySyncKHR; + static const Function eglClientWaitSyncKHR = Message_Function_eglClientWaitSyncKHR; + static const Function eglGetSyncAttribKHR = Message_Function_eglGetSyncAttribKHR; + static const Function eglSetSwapRectangleANDROID = Message_Function_eglSetSwapRectangleANDROID; + static const Function eglGetRenderBufferANDROID = Message_Function_eglGetRenderBufferANDROID; + static const Function ACK = Message_Function_ACK; + static const Function NEG = Message_Function_NEG; + static const Function CONTINUE = Message_Function_CONTINUE; + static const Function SKIP = Message_Function_SKIP; + static const Function SETPROP = Message_Function_SETPROP; + static const Function CAPTURE = Message_Function_CAPTURE; + static inline bool Function_IsValid(int value) { + return Message_Function_IsValid(value); + } + static const Function Function_MIN = + Message_Function_Function_MIN; + static const Function Function_MAX = + Message_Function_Function_MAX; + static const int Function_ARRAYSIZE = + Message_Function_Function_ARRAYSIZE; + + typedef Message_Type Type; + static const Type BeforeCall = Message_Type_BeforeCall; + static const Type AfterCall = Message_Type_AfterCall; + static const Type Response = Message_Type_Response; + static inline bool Type_IsValid(int value) { + return Message_Type_IsValid(value); + } + static const Type Type_MIN = + Message_Type_Type_MIN; + static const Type Type_MAX = + Message_Type_Type_MAX; + static const int Type_ARRAYSIZE = + Message_Type_Type_ARRAYSIZE; + + typedef Message_Prop Prop; + static const Prop Capture = Message_Prop_Capture; + static const Prop TimeMode = Message_Prop_TimeMode; + static inline bool Prop_IsValid(int value) { + return Message_Prop_IsValid(value); + } + static const Prop Prop_MIN = + Message_Prop_Prop_MIN; + static const Prop Prop_MAX = + Message_Prop_Prop_MAX; + static const int Prop_ARRAYSIZE = + Message_Prop_Prop_ARRAYSIZE; + + // accessors ------------------------------------------------------- + + // required int32 context_id = 1; + inline bool has_context_id() const; + inline void clear_context_id(); + static const int kContextIdFieldNumber = 1; + inline ::google::protobuf::int32 context_id() const; + inline void set_context_id(::google::protobuf::int32 value); + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + inline bool has_function() const; + inline void clear_function(); + static const int kFunctionFieldNumber = 2; + inline ::com::android::glesv2debugger::Message_Function function() const; + inline void set_function(::com::android::glesv2debugger::Message_Function value); + + // required .com.android.glesv2debugger.Message.Type type = 3; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 3; + inline ::com::android::glesv2debugger::Message_Type type() const; + inline void set_type(::com::android::glesv2debugger::Message_Type value); + + // required bool expect_response = 4; + inline bool has_expect_response() const; + inline void clear_expect_response(); + static const int kExpectResponseFieldNumber = 4; + inline bool expect_response() const; + inline void set_expect_response(bool value); + + // optional int32 ret = 5; + inline bool has_ret() const; + inline void clear_ret(); + static const int kRetFieldNumber = 5; + inline ::google::protobuf::int32 ret() const; + inline void set_ret(::google::protobuf::int32 value); + + // optional int32 arg0 = 6; + inline bool has_arg0() const; + inline void clear_arg0(); + static const int kArg0FieldNumber = 6; + inline ::google::protobuf::int32 arg0() const; + inline void set_arg0(::google::protobuf::int32 value); + + // optional int32 arg1 = 7; + inline bool has_arg1() const; + inline void clear_arg1(); + static const int kArg1FieldNumber = 7; + inline ::google::protobuf::int32 arg1() const; + inline void set_arg1(::google::protobuf::int32 value); + + // optional int32 arg2 = 8; + inline bool has_arg2() const; + inline void clear_arg2(); + static const int kArg2FieldNumber = 8; + inline ::google::protobuf::int32 arg2() const; + inline void set_arg2(::google::protobuf::int32 value); + + // optional int32 arg3 = 9; + inline bool has_arg3() const; + inline void clear_arg3(); + static const int kArg3FieldNumber = 9; + inline ::google::protobuf::int32 arg3() const; + inline void set_arg3(::google::protobuf::int32 value); + + // optional int32 arg4 = 16; + inline bool has_arg4() const; + inline void clear_arg4(); + static const int kArg4FieldNumber = 16; + inline ::google::protobuf::int32 arg4() const; + inline void set_arg4(::google::protobuf::int32 value); + + // optional int32 arg5 = 17; + inline bool has_arg5() const; + inline void clear_arg5(); + static const int kArg5FieldNumber = 17; + inline ::google::protobuf::int32 arg5() const; + inline void set_arg5(::google::protobuf::int32 value); + + // optional int32 arg6 = 18; + inline bool has_arg6() const; + inline void clear_arg6(); + static const int kArg6FieldNumber = 18; + inline ::google::protobuf::int32 arg6() const; + inline void set_arg6(::google::protobuf::int32 value); + + // optional int32 arg7 = 19; + inline bool has_arg7() const; + inline void clear_arg7(); + static const int kArg7FieldNumber = 19; + inline ::google::protobuf::int32 arg7() const; + inline void set_arg7(::google::protobuf::int32 value); + + // optional int32 arg8 = 20; + inline bool has_arg8() const; + inline void clear_arg8(); + static const int kArg8FieldNumber = 20; + inline ::google::protobuf::int32 arg8() const; + inline void set_arg8(::google::protobuf::int32 value); + + // optional bytes data = 10; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 10; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + + // optional float time = 11; + inline bool has_time() const; + inline void clear_time(); + static const int kTimeFieldNumber = 11; + inline float time() const; + inline void set_time(float value); + + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + inline bool has_prop() const; + inline void clear_prop(); + static const int kPropFieldNumber = 21; + inline ::com::android::glesv2debugger::Message_Prop prop() const; + inline void set_prop(::com::android::glesv2debugger::Message_Prop value); + + // optional float clock = 22; + inline bool has_clock() const; + inline void clear_clock(); + static const int kClockFieldNumber = 22; + inline float clock() const; + inline void set_clock(float value); + + // @@protoc_insertion_point(class_scope:com.android.glesv2debugger.Message) + private: + mutable int _cached_size_; + + ::google::protobuf::int32 context_id_; + int function_; + int type_; + bool expect_response_; + ::google::protobuf::int32 ret_; + ::google::protobuf::int32 arg0_; + ::google::protobuf::int32 arg1_; + ::google::protobuf::int32 arg2_; + ::google::protobuf::int32 arg3_; + ::google::protobuf::int32 arg4_; + ::google::protobuf::int32 arg5_; + ::google::protobuf::int32 arg6_; + ::google::protobuf::int32 arg7_; + ::google::protobuf::int32 arg8_; + ::std::string* data_; + static const ::std::string _default_data_; + float time_; + int prop_; + float clock_; + friend void protobuf_AddDesc_debugger_5fmessage_2eproto(); + friend void protobuf_AssignDesc_debugger_5fmessage_2eproto(); + friend void protobuf_ShutdownFile_debugger_5fmessage_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(18 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static Message* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// Message + +// required int32 context_id = 1; +inline bool Message::has_context_id() const { + return _has_bit(0); +} +inline void Message::clear_context_id() { + context_id_ = 0; + _clear_bit(0); +} +inline ::google::protobuf::int32 Message::context_id() const { + return context_id_; +} +inline void Message::set_context_id(::google::protobuf::int32 value) { + _set_bit(0); + context_id_ = value; +} + +// required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; +inline bool Message::has_function() const { + return _has_bit(1); +} +inline void Message::clear_function() { + function_ = 187; + _clear_bit(1); +} +inline ::com::android::glesv2debugger::Message_Function Message::function() const { + return static_cast< ::com::android::glesv2debugger::Message_Function >(function_); +} +inline void Message::set_function(::com::android::glesv2debugger::Message_Function value) { + GOOGLE_DCHECK(::com::android::glesv2debugger::Message_Function_IsValid(value)); + _set_bit(1); + function_ = value; +} + +// required .com.android.glesv2debugger.Message.Type type = 3; +inline bool Message::has_type() const { + return _has_bit(2); +} +inline void Message::clear_type() { + type_ = 0; + _clear_bit(2); +} +inline ::com::android::glesv2debugger::Message_Type Message::type() const { + return static_cast< ::com::android::glesv2debugger::Message_Type >(type_); +} +inline void Message::set_type(::com::android::glesv2debugger::Message_Type value) { + GOOGLE_DCHECK(::com::android::glesv2debugger::Message_Type_IsValid(value)); + _set_bit(2); + type_ = value; +} + +// required bool expect_response = 4; +inline bool Message::has_expect_response() const { + return _has_bit(3); +} +inline void Message::clear_expect_response() { + expect_response_ = false; + _clear_bit(3); +} +inline bool Message::expect_response() const { + return expect_response_; +} +inline void Message::set_expect_response(bool value) { + _set_bit(3); + expect_response_ = value; +} + +// optional int32 ret = 5; +inline bool Message::has_ret() const { + return _has_bit(4); +} +inline void Message::clear_ret() { + ret_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 Message::ret() const { + return ret_; +} +inline void Message::set_ret(::google::protobuf::int32 value) { + _set_bit(4); + ret_ = value; +} + +// optional int32 arg0 = 6; +inline bool Message::has_arg0() const { + return _has_bit(5); +} +inline void Message::clear_arg0() { + arg0_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 Message::arg0() const { + return arg0_; +} +inline void Message::set_arg0(::google::protobuf::int32 value) { + _set_bit(5); + arg0_ = value; +} + +// optional int32 arg1 = 7; +inline bool Message::has_arg1() const { + return _has_bit(6); +} +inline void Message::clear_arg1() { + arg1_ = 0; + _clear_bit(6); +} +inline ::google::protobuf::int32 Message::arg1() const { + return arg1_; +} +inline void Message::set_arg1(::google::protobuf::int32 value) { + _set_bit(6); + arg1_ = value; +} + +// optional int32 arg2 = 8; +inline bool Message::has_arg2() const { + return _has_bit(7); +} +inline void Message::clear_arg2() { + arg2_ = 0; + _clear_bit(7); +} +inline ::google::protobuf::int32 Message::arg2() const { + return arg2_; +} +inline void Message::set_arg2(::google::protobuf::int32 value) { + _set_bit(7); + arg2_ = value; +} + +// optional int32 arg3 = 9; +inline bool Message::has_arg3() const { + return _has_bit(8); +} +inline void Message::clear_arg3() { + arg3_ = 0; + _clear_bit(8); +} +inline ::google::protobuf::int32 Message::arg3() const { + return arg3_; +} +inline void Message::set_arg3(::google::protobuf::int32 value) { + _set_bit(8); + arg3_ = value; +} + +// optional int32 arg4 = 16; +inline bool Message::has_arg4() const { + return _has_bit(9); +} +inline void Message::clear_arg4() { + arg4_ = 0; + _clear_bit(9); +} +inline ::google::protobuf::int32 Message::arg4() const { + return arg4_; +} +inline void Message::set_arg4(::google::protobuf::int32 value) { + _set_bit(9); + arg4_ = value; +} + +// optional int32 arg5 = 17; +inline bool Message::has_arg5() const { + return _has_bit(10); +} +inline void Message::clear_arg5() { + arg5_ = 0; + _clear_bit(10); +} +inline ::google::protobuf::int32 Message::arg5() const { + return arg5_; +} +inline void Message::set_arg5(::google::protobuf::int32 value) { + _set_bit(10); + arg5_ = value; +} + +// optional int32 arg6 = 18; +inline bool Message::has_arg6() const { + return _has_bit(11); +} +inline void Message::clear_arg6() { + arg6_ = 0; + _clear_bit(11); +} +inline ::google::protobuf::int32 Message::arg6() const { + return arg6_; +} +inline void Message::set_arg6(::google::protobuf::int32 value) { + _set_bit(11); + arg6_ = value; +} + +// optional int32 arg7 = 19; +inline bool Message::has_arg7() const { + return _has_bit(12); +} +inline void Message::clear_arg7() { + arg7_ = 0; + _clear_bit(12); +} +inline ::google::protobuf::int32 Message::arg7() const { + return arg7_; +} +inline void Message::set_arg7(::google::protobuf::int32 value) { + _set_bit(12); + arg7_ = value; +} + +// optional int32 arg8 = 20; +inline bool Message::has_arg8() const { + return _has_bit(13); +} +inline void Message::clear_arg8() { + arg8_ = 0; + _clear_bit(13); +} +inline ::google::protobuf::int32 Message::arg8() const { + return arg8_; +} +inline void Message::set_arg8(::google::protobuf::int32 value) { + _set_bit(13); + arg8_ = value; +} + +// optional bytes data = 10; +inline bool Message::has_data() const { + return _has_bit(14); +} +inline void Message::clear_data() { + if (data_ != &_default_data_) { + data_->clear(); + } + _clear_bit(14); +} +inline const ::std::string& Message::data() const { + return *data_; +} +inline void Message::set_data(const ::std::string& value) { + _set_bit(14); + if (data_ == &_default_data_) { + data_ = new ::std::string; + } + data_->assign(value); +} +inline void Message::set_data(const char* value) { + _set_bit(14); + if (data_ == &_default_data_) { + data_ = new ::std::string; + } + data_->assign(value); +} +inline void Message::set_data(const void* value, size_t size) { + _set_bit(14); + if (data_ == &_default_data_) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast<const char*>(value), size); +} +inline ::std::string* Message::mutable_data() { + _set_bit(14); + if (data_ == &_default_data_) { + data_ = new ::std::string; + } + return data_; +} + +// optional float time = 11; +inline bool Message::has_time() const { + return _has_bit(15); +} +inline void Message::clear_time() { + time_ = 0; + _clear_bit(15); +} +inline float Message::time() const { + return time_; +} +inline void Message::set_time(float value) { + _set_bit(15); + time_ = value; +} + +// optional .com.android.glesv2debugger.Message.Prop prop = 21; +inline bool Message::has_prop() const { + return _has_bit(16); +} +inline void Message::clear_prop() { + prop_ = 0; + _clear_bit(16); +} +inline ::com::android::glesv2debugger::Message_Prop Message::prop() const { + return static_cast< ::com::android::glesv2debugger::Message_Prop >(prop_); +} +inline void Message::set_prop(::com::android::glesv2debugger::Message_Prop value) { + GOOGLE_DCHECK(::com::android::glesv2debugger::Message_Prop_IsValid(value)); + _set_bit(16); + prop_ = value; +} + +// optional float clock = 22; +inline bool Message::has_clock() const { + return _has_bit(17); +} +inline void Message::clear_clock() { + clock_ = 0; + _clear_bit(17); +} +inline float Message::clock() const { + return clock_; +} +inline void Message::set_clock(float value) { + _set_bit(17); + clock_ = value; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace glesv2debugger +} // namespace android +} // namespace com + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_debugger_5fmessage_2eproto__INCLUDED diff --git a/opengl/libs/GLES2_dbg/src/egl.cpp b/opengl/libs/GLES2_dbg/src/egl.cpp new file mode 100644 index 0000000..b3979a3 --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/egl.cpp @@ -0,0 +1,41 @@ +/* + ** 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. + */ + +#include "header.h" + +EGLBoolean Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) +{ + glesv2debugger::Message msg; + const bool expectResponse = true; + struct : public FunctionCall { + EGLDisplay dpy; + EGLSurface draw; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + msg.set_time(-1); + return reinterpret_cast<const int *>(true); + } + } caller; + caller.dpy = dpy; + caller.draw = draw; + + msg.set_arg0(reinterpret_cast<int>(dpy)); + msg.set_arg1(reinterpret_cast<int>(draw)); + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_eglSwapBuffers); + return static_cast<EGLBoolean>(reinterpret_cast<int>(ret)); +} diff --git a/opengl/libs/GLES2_dbg/src/header.h b/opengl/libs/GLES2_dbg/src/header.h new file mode 100644 index 0000000..cbd448a --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/header.h @@ -0,0 +1,129 @@ +/* + ** 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. + */ + +#include <stdlib.h> +#include <ctype.h> +#include <string.h> +#include <errno.h> + +#include <GLES2/gl2.h> +#include <GLES2/gl2ext.h> + +#include <cutils/log.h> +#include <utils/Timers.h> +#include <../../../libcore/include/StaticAssert.h> + +#define EGL_TRACE 1 +#include "hooks.h" + +#include "glesv2dbg.h" + +#define GL_ENTRY(_r, _api, ...) _r Debug_##_api ( __VA_ARGS__ ); +#include "glesv2dbg_functions.h" + +#include "debugger_message.pb.h" + +using namespace android; +using namespace com::android; + +#define API_ENTRY(_api) Debug_##_api + +#ifndef __location__ +#define __HIERALLOC_STRING_0__(s) #s +#define __HIERALLOC_STRING_1__(s) __HIERALLOC_STRING_0__(s) +#define __HIERALLOC_STRING_2__ __HIERALLOC_STRING_1__(__LINE__) +#define __location__ __FILE__ ":" __HIERALLOC_STRING_2__ +#endif + +#undef assert +#define assert(expr) if (!(expr)) { LOGD("\n*\n*\n* assert: %s at %s \n*\n*", #expr, __location__); int * x = 0; *x = 5; } +//#undef LOGD +//#define LOGD(...) + +namespace android +{ + +struct DbgContext { + const unsigned version; // 0 is GLES1, 1 is GLES2 + const gl_hooks_t * const hooks; + const unsigned MAX_VERTEX_ATTRIBS; + + struct VertexAttrib { + GLenum type; // element data type + unsigned size; // number of data per element + unsigned stride; // calculated number of bytes between elements + const void * ptr; + unsigned elemSize; // calculated number of bytes per element + GLuint buffer; // buffer name + GLboolean normalized : 1; + GLboolean enabled : 1; + VertexAttrib() : type(0), size(0), stride(0), ptr(NULL), elemSize(0), + buffer(0), normalized(0), enabled(0) {} + } * vertexAttribs; + bool hasNonVBOAttribs; // whether any enabled vertexAttrib is user pointer + + struct VBO { + const GLuint name; + const GLenum target; + VBO * next; + void * data; // malloc/free + unsigned size; // in bytes + VBO(const GLuint name, const GLenum target, VBO * head) : name(name), + target(target), next(head), data(NULL), size(0) {} + } * indexBuffers; // linked list of all index buffers + VBO * indexBuffer; // currently bound index buffer + + GLuint program; + unsigned maxAttrib; // number of slots used by program + + DbgContext(const unsigned version, const gl_hooks_t * const hooks, const unsigned MAX_VERTEX_ATTRIBS); + ~DbgContext(); + + void Fetch(const unsigned index, std::string * const data) const; + + void glUseProgram(GLuint program); + void glEnableVertexAttribArray(GLuint index); + void glDisableVertexAttribArray(GLuint index); + void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); + void glBindBuffer(GLenum target, GLuint buffer); + void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); + void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); + void glDeleteBuffers(GLsizei n, const GLuint *buffers); +}; + + +DbgContext * getDbgContextThreadSpecific(); +#define DBGCONTEXT(ctx) DbgContext * const ctx = getDbgContextThreadSpecific(); + +struct FunctionCall { + virtual const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) = 0; + virtual ~FunctionCall() {} +}; + +// move these into DbgContext +extern bool capture; +extern int timeMode; // SYSTEM_TIME_ + +extern int clientSock, serverSock; + +unsigned GetBytesPerPixel(const GLenum format, const GLenum type); + +int * MessageLoop(FunctionCall & functionCall, glesv2debugger::Message & msg, + const bool expectResponse, const glesv2debugger::Message_Function function); +void Receive(glesv2debugger::Message & cmd); +float Send(const glesv2debugger::Message & msg, glesv2debugger::Message & cmd); +void SetProp(const glesv2debugger::Message & cmd); +}; // namespace android { diff --git a/opengl/libs/GLES2_dbg/src/server.cpp b/opengl/libs/GLES2_dbg/src/server.cpp new file mode 100644 index 0000000..820e9de --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/server.cpp @@ -0,0 +1,228 @@ +/* + ** 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. + */ + +#include <sys/ioctl.h> +#include <unistd.h> +#include <sys/socket.h> +#include <fcntl.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <pthread.h> + +#include "header.h" + +namespace android +{ + +int serverSock = -1, clientSock = -1; + +int timeMode = SYSTEM_TIME_THREAD; + +static void Die(const char * msg) +{ + LOGD("\n*\n*\n* GLESv2_dbg: Die: %s \n*\n*", msg); + StopDebugServer(); + exit(1); +} + +void StartDebugServer() +{ + LOGD("GLESv2_dbg: StartDebugServer"); + if (serverSock >= 0) + return; + + LOGD("GLESv2_dbg: StartDebugServer create socket"); + struct sockaddr_in server = {}, client = {}; + + /* Create the TCP socket */ + if ((serverSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { + Die("Failed to create socket"); + } + /* Construct the server sockaddr_in structure */ + server.sin_family = AF_INET; /* Internet/IP */ + server.sin_addr.s_addr = htonl(INADDR_ANY); /* Incoming addr */ + server.sin_port = htons(5039); /* server port */ + + /* Bind the server socket */ + socklen_t sizeofSockaddr_in = sizeof(sockaddr_in); + if (bind(serverSock, (struct sockaddr *) &server, + sizeof(server)) < 0) { + Die("Failed to bind the server socket"); + } + /* Listen on the server socket */ + if (listen(serverSock, 1) < 0) { + Die("Failed to listen on server socket"); + } + + LOGD("server started on %d \n", server.sin_port); + + + /* Wait for client connection */ + if ((clientSock = + accept(serverSock, (struct sockaddr *) &client, + &sizeofSockaddr_in)) < 0) { + Die("Failed to accept client connection"); + } + + LOGD("Client connected: %s\n", inet_ntoa(client.sin_addr)); +// fcntl(clientSock, F_SETFL, O_NONBLOCK); + + glesv2debugger::Message msg, cmd; + msg.set_context_id(0); + msg.set_function(glesv2debugger::Message_Function_ACK); + msg.set_type(glesv2debugger::Message_Type_Response); + msg.set_expect_response(false); + Send(msg, cmd); +} + +void StopDebugServer() +{ + LOGD("GLESv2_dbg: StopDebugServer"); + if (clientSock > 0) { + close(clientSock); + clientSock = -1; + } + if (serverSock > 0) { + close(serverSock); + serverSock = -1; + } + +} + +void Receive(glesv2debugger::Message & cmd) +{ + unsigned len = 0; + + int received = recv(clientSock, &len, 4, MSG_WAITALL); + if (received < 0) + Die("Failed to receive response length"); + else if (4 != received) { + LOGD("received %dB: %.8X", received, len); + Die("Received length mismatch, expected 4"); + } + len = ntohl(len); + static void * buffer = NULL; + static unsigned bufferSize = 0; + if (bufferSize < len) { + buffer = realloc(buffer, len); + assert(buffer); + bufferSize = len; + } + received = recv(clientSock, buffer, len, MSG_WAITALL); + if (received < 0) + Die("Failed to receive response"); + else if (len != received) + Die("Received length mismatch"); + cmd.Clear(); + cmd.ParseFromArray(buffer, len); +} + +float Send(const glesv2debugger::Message & msg, glesv2debugger::Message & cmd) +{ + static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&mutex); // TODO: this is just temporary + + if (msg.function() != glesv2debugger::Message_Function_ACK) + assert(msg.has_context_id() && msg.context_id() != 0); + static std::string str; + msg.SerializeToString(&str); + unsigned len = str.length(); + len = htonl(len); + int sent = -1; + sent = send(clientSock, (const char *)&len, sizeof(len), 0); + if (sent != sizeof(len)) { + LOGD("actual sent=%d expected=%d clientSock=%d", sent, sizeof(len), clientSock); + Die("Failed to send message length"); + } + nsecs_t c0 = systemTime(timeMode); + sent = send(clientSock, str.c_str(), str.length(), 0); + float t = (float)ns2ms(systemTime(timeMode) - c0); + if (sent != str.length()) { + LOGD("actual sent=%d expected=%d clientSock=%d", sent, str.length(), clientSock); + Die("Failed to send message"); + } + + if (!msg.expect_response()) { + pthread_mutex_unlock(&mutex); + return t; + } + + Receive(cmd); + + //LOGD("Message sent tid=%lu len=%d", pthread_self(), str.length()); + pthread_mutex_unlock(&mutex); + return t; +} + +void SetProp(const glesv2debugger::Message & cmd) +{ + switch (cmd.prop()) { + case glesv2debugger::Message_Prop_Capture: + LOGD("SetProp Message_Prop_Capture %d", cmd.arg0()); + capture = cmd.arg0(); + break; + case glesv2debugger::Message_Prop_TimeMode: + LOGD("SetProp Message_Prop_TimeMode %d", cmd.arg0()); + timeMode = cmd.arg0(); + break; + default: + assert(0); + } +} + +int * MessageLoop(FunctionCall & functionCall, glesv2debugger::Message & msg, + const bool expectResponse, const glesv2debugger::Message_Function function) +{ + DbgContext * const dbg = getDbgContextThreadSpecific(); + const int * ret = 0; + glesv2debugger::Message cmd; + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_type(glesv2debugger::Message_Type_BeforeCall); + msg.set_expect_response(expectResponse); + msg.set_function(function); + Send(msg, cmd); + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_CONTINUE); + while (true) { + msg.Clear(); + nsecs_t c0 = systemTime(timeMode); + switch (cmd.function()) { + case glesv2debugger::Message_Function_CONTINUE: + ret = functionCall(&dbg->hooks->gl, msg); + if (!msg.has_time()) // some has output data copy, so time inside call + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_function(function); + msg.set_type(glesv2debugger::Message_Type_AfterCall); + msg.set_expect_response(expectResponse); + Send(msg, cmd); + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + case glesv2debugger::Message_Function_SKIP: + return const_cast<int *>(ret); + case glesv2debugger::Message_Function_SETPROP: + SetProp(cmd); + Receive(cmd); + break; + default: + assert(0); //GenerateCall(msg, cmd); + break; + } + } + return 0; +} +}; // namespace android { diff --git a/opengl/libs/GLES2_dbg/src/texture.cpp b/opengl/libs/GLES2_dbg/src/texture.cpp new file mode 100644 index 0000000..3aa0aab --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/texture.cpp @@ -0,0 +1,265 @@ +/* + ** 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. + */ + +#include "header.h" + +namespace android +{ +unsigned GetBytesPerPixel(const GLenum format, const GLenum type) +{ + switch (type) { + case GL_UNSIGNED_SHORT_5_6_5: + return 2; + case GL_UNSIGNED_SHORT_4_4_4_4: + return 2; + case GL_UNSIGNED_SHORT_5_5_5_1: + return 2; + case GL_UNSIGNED_BYTE: + break; + default: + assert(0); + } + + switch (format) { + case GL_ALPHA: + return 1; + case GL_LUMINANCE: + return 1; + break; + case GL_LUMINANCE_ALPHA: + return 2; + case GL_RGB: + return 3; + case GL_RGBA: + return 4; + default: + assert(0); + return 0; + } +} + +#define USE_RLE 0 +#if USE_RLE +export template<typename T> +void * RLEEncode(const void * pixels, unsigned count, unsigned * encodedSize) +{ + // first is a byte indicating data size [1,2,4] bytes + // then an unsigned indicating decompressed size + // then a byte of header: MSB == 1 indicates run, else literal + // LSB7 is run or literal length (actual length - 1) + + const T * data = (T *)pixels; + unsigned bufferSize = sizeof(T) * count / 2 + 8; + unsigned char * buffer = (unsigned char *)malloc(bufferSize); + buffer[0] = sizeof(T); + unsigned bufferWritten = 1; // number of bytes written + *(unsigned *)(buffer + bufferWritten) = count; + bufferWritten += sizeof(count); + while (count) { + unsigned char run = 1; + bool repeat = true; + for (run = 1; run < count; run++) + if (data[0] != data[run]) { + repeat = false; + break; + } else if (run > 126) + break; + if (!repeat) { + // find literal length + for (run = 1; run < count; run++) + if (data[run - 1] == data[run]) + break; + else if (run > 126) + break; + unsigned bytesToWrite = 1 + sizeof(T) * run; + if (bufferWritten + bytesToWrite > bufferSize) { + bufferSize += sizeof(T) * run + 256; + buffer = (unsigned char *)realloc(buffer, bufferSize); + } + buffer[bufferWritten++] = run - 1; + for (unsigned i = 0; i < run; i++) { + *(T *)(buffer + bufferWritten) = *data; + bufferWritten += sizeof(T); + data++; + } + count -= run; + } else { + unsigned bytesToWrite = 1 + sizeof(T); + if (bufferWritten + bytesToWrite > bufferSize) { + bufferSize += 256; + buffer = (unsigned char *)realloc(buffer, bufferSize); + } + buffer[bufferWritten++] = (run - 1) | 0x80; + *(T *)(buffer + bufferWritten) = data[0]; + bufferWritten += sizeof(T); + data += run; + count -= run; + } + } + if (encodedSize) + *encodedSize = bufferWritten; + return buffer; +} + +void * RLEEncode(const void * pixels, const unsigned bytesPerPixel, const unsigned count, unsigned * encodedSize) +{ + switch (bytesPerPixel) { + case 4: + return RLEEncode<int>(pixels, count, encodedSize); + case 2: + return RLEEncode<short>(pixels, count, encodedSize); + case 1: + return RLEEncode<char>(pixels, count, encodedSize); + default: + assert(0); + return NULL; + } +} +#endif +}; // namespace android + +void Debug_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLint internalformat; + GLsizei width; + GLsizei height; + GLint border; + GLenum format; + GLenum type; + const GLvoid* pixels; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + return 0; + } + } caller; + caller.target = target; + caller.level = level; + caller.internalformat = internalformat; + caller.width = width; + caller.height = height; + caller.border = border; + caller.format = format; + caller.type = type; + caller.pixels = pixels; + + 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(format); + msg.set_arg7(type); + msg.set_arg8(reinterpret_cast<int>(pixels)); + + if (pixels) { + assert(internalformat == format); + assert(0 == border); + + unsigned bytesPerPixel = GetBytesPerPixel(format, type); + assert(0 < bytesPerPixel); + +// LOGD("GLESv2_dbg: glTexImage2D width=%d height=%d level=%d bytesPerPixel=%d", +// width, height, level, bytesPerPixel); +#if USE_RLE + unsigned encodedSize = 0; + void * data = RLEEncode(pixels, bytesPerPixel, width * height, &encodedSize); + msg.set_data(data, encodedSize); + free(data); + if (encodedSize > bytesPerPixel * width * height) + LOGD("GLESv2_dbg: glTexImage2D sending data encodedSize=%d size=%d", encodedSize, bytesPerPixel * width * height); +#else + msg.set_data(pixels, bytesPerPixel * width * height); +#endif + } + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexImage2D); +} + +void Debug_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) +{ + glesv2debugger::Message msg; + const bool expectResponse = false; + struct : public FunctionCall { + GLenum target; + GLint level; + GLint xoffset; + GLint yoffset; + GLsizei width; + GLsizei height; + GLenum format; + GLenum type; + const GLvoid* pixels; + + const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { + nsecs_t c0 = systemTime(timeMode); + _c->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + 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.type = type; + caller.pixels = pixels; + + 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(type); + msg.set_arg8(reinterpret_cast<int>(pixels)); + + assert(pixels); + if (pixels) { + unsigned bytesPerPixel = GetBytesPerPixel(format, type); + assert(0 < bytesPerPixel); + +// LOGD("GLESv2_dbg: glTexSubImage2D width=%d height=%d level=%d bytesPerPixel=%d", +// width, height, level, bytesPerPixel); + +#if USE_RLE + unsigned encodedSize = 0; + void * data = RLEEncode(pixels, bytesPerPixel, width * height, &encodedSize); + msg.set_data(data, encodedSize); + free(data); + if (encodedSize > bytesPerPixel * width * height) + LOGD("GLESv2_dbg: glTexImage2D sending data encodedSize=%d size=%d", encodedSize, bytesPerPixel * width * height); +#else + msg.set_data(pixels, bytesPerPixel * width * height); +#endif + } + + int * ret = MessageLoop(caller, msg, expectResponse, + glesv2debugger::Message_Function_glTexSubImage2D); +}
\ No newline at end of file diff --git a/opengl/libs/GLES2_dbg/src/vertex.cpp b/opengl/libs/GLES2_dbg/src/vertex.cpp new file mode 100644 index 0000000..52ce907 --- /dev/null +++ b/opengl/libs/GLES2_dbg/src/vertex.cpp @@ -0,0 +1,231 @@ +/* + ** 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. + */ + +#include "header.h" + +namespace android +{ +bool capture; // capture after each glDraw* + +void * RLEEncode(const void * pixels, const unsigned bytesPerPixel, const unsigned count, unsigned * encodedSize); +} + +void Debug_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) +{ + DbgContext * const dbg = getDbgContextThreadSpecific(); + glesv2debugger::Message msg, cmd; + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_type(glesv2debugger::Message_Type_BeforeCall); + const bool expectResponse = false; + msg.set_expect_response(expectResponse); + msg.set_function(glesv2debugger::Message_Function_glReadPixels); + msg.set_arg0(x); + msg.set_arg1(y); + msg.set_arg2(width); + msg.set_arg3(height); + msg.set_arg4(format); + msg.set_arg5(type); + msg.set_arg6(reinterpret_cast<int>(pixels)); + //void * data = NULL; + //unsigned encodedSize = 0; + Send(msg, cmd); + float t = 0; + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_CONTINUE); + while (true) { + msg.Clear(); + nsecs_t c0 = systemTime(timeMode); + switch (cmd.function()) { + case glesv2debugger::Message_Function_CONTINUE: + dbg->hooks->gl.glReadPixels(x, y, width, height, format, type, pixels); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_function(glesv2debugger::Message_Function_glReadPixels); + msg.set_type(glesv2debugger::Message_Type_AfterCall); + msg.set_expect_response(expectResponse); + //data = RLEEncode(pixels, GetBytesPerPixel(format, type), width * height, &encodedSize); + msg.set_data(pixels, width * height * GetBytesPerPixel(format, type)); + //msg.set_data(data, encodedSize); + //free(data); + c0 = systemTime(timeMode); + t = Send(msg, cmd); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.set_clock(t); + // time is total send time in seconds, clock is msg serialization time in seconds + msg.clear_data(); + msg.set_expect_response(false); + msg.set_type(glesv2debugger::Message_Type_AfterCall); + //Send(msg, cmd); + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + case glesv2debugger::Message_Function_SKIP: + return; + default: + assert(0); //GenerateCall(msg, cmd); + break; + } + } +} + +void Debug_glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + DbgContext * const dbg = getDbgContextThreadSpecific(); + glesv2debugger::Message msg, cmd; + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_type(glesv2debugger::Message_Type_BeforeCall); + const bool expectResponse = false; + msg.set_expect_response(expectResponse); + msg.set_function(glesv2debugger::Message_Function_glDrawArrays); + msg.set_arg0(mode); + msg.set_arg1(first); + msg.set_arg2(count); + + msg.set_arg7(dbg->maxAttrib); // indicate capturing vertex data + if (dbg->hasNonVBOAttribs) { + std::string * const data = msg.mutable_data(); + for (unsigned i = 0; i < count; i++) + dbg->Fetch(i + first, data); + } + + void * pixels = NULL; + GLint readFormat = 0, readType = 0; + int viewport[4] = {}; + Send(msg, cmd); + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_CONTINUE); + while (true) { + msg.Clear(); + nsecs_t c0 = systemTime(timeMode); + switch (cmd.function()) { + case glesv2debugger::Message_Function_CONTINUE: + dbg->hooks->gl.glDrawArrays(mode, first, count); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_function(glesv2debugger::Message_Function_glDrawArrays); + msg.set_type(glesv2debugger::Message_Type_AfterCall); + msg.set_expect_response(expectResponse); + Send(msg, cmd); + if (capture) + cmd.set_function(glesv2debugger::Message_Function_CAPTURE); + else if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + case glesv2debugger::Message_Function_SKIP: + return; + case glesv2debugger::Message_Function_CAPTURE: + dbg->hooks->gl.glGetIntegerv(GL_VIEWPORT, viewport); + dbg->hooks->gl.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat); + dbg->hooks->gl.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType); + LOGD("glDrawArrays CAPTURE: x=%d y=%d width=%d height=%d format=0x%.4X type=0x%.4X", + viewport[0], viewport[1], viewport[2], viewport[3], readFormat, readType); + pixels = malloc(viewport[2] * viewport[3] * 4); + Debug_glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], + readFormat, readType, pixels); + free(pixels); + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + default: + assert(0); //GenerateCall(msg, cmd); + break; + } + } +} + +template<typename T> +static inline void FetchIndexed(const unsigned count, const T * indices, + std::string * const data, const DbgContext * const ctx) +{ + for (unsigned i = 0; i < count; i++) { + if (!ctx->indexBuffer) + data->append((const char *)(indices + i), sizeof(*indices)); + if (ctx->hasNonVBOAttribs) + ctx->Fetch(indices[i], data); + } +} + +void Debug_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) +{ + DbgContext * const dbg = getDbgContextThreadSpecific(); + glesv2debugger::Message msg, cmd; + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_type(glesv2debugger::Message_Type_BeforeCall); + const bool expectResponse = false; + msg.set_expect_response(expectResponse); + msg.set_function(glesv2debugger::Message_Function_glDrawElements); + msg.set_arg0(mode); + msg.set_arg1(count); + msg.set_arg2(type); + msg.set_arg3(reinterpret_cast<int>(indices)); + + msg.set_arg7(dbg->maxAttrib); // indicate capturing vertex data + std::string * const data = msg.mutable_data(); + if (GL_UNSIGNED_BYTE == type) { + if (dbg->indexBuffer) + FetchIndexed(count, (unsigned char *)dbg->indexBuffer->data + (unsigned long)indices, data, dbg); + else + FetchIndexed(count, (unsigned char *)indices, data, dbg); + } else if (GL_UNSIGNED_SHORT == type) { + if (dbg->indexBuffer) + FetchIndexed(count, (unsigned short *)((char *)dbg->indexBuffer->data + (unsigned long)indices), data, dbg); + else + FetchIndexed(count, (unsigned short *)indices, data, dbg); + } else + assert(0); + + void * pixels = NULL; + GLint readFormat = 0, readType = 0; + int viewport[4] = {}; + Send(msg, cmd); + if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_CONTINUE); + while (true) { + msg.Clear(); + nsecs_t c0 = systemTime(timeMode); + switch (cmd.function()) { + case glesv2debugger::Message_Function_CONTINUE: + dbg->hooks->gl.glDrawElements(mode, count, type, indices); + msg.set_time((systemTime(timeMode) - c0) * 1e-6f); + msg.set_context_id(reinterpret_cast<int>(dbg)); + msg.set_function(glesv2debugger::Message_Function_glDrawElements); + msg.set_type(glesv2debugger::Message_Type_AfterCall); + msg.set_expect_response(expectResponse); + Send(msg, cmd); + if (capture) + cmd.set_function(glesv2debugger::Message_Function_CAPTURE); + else if (!expectResponse) + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + case glesv2debugger::Message_Function_SKIP: + return; + case glesv2debugger::Message_Function_CAPTURE: + dbg->hooks->gl.glGetIntegerv(GL_VIEWPORT, viewport); + dbg->hooks->gl.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat); + dbg->hooks->gl.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType); + LOGD("glDrawArrays CAPTURE: x=%d y=%d width=%d height=%d format=0x%.4X type=0x%.4X", + viewport[0], viewport[1], viewport[2], viewport[3], readFormat, readType); + pixels = malloc(viewport[2] * viewport[3] * 4); + Debug_glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], + readFormat, readType, pixels); + free(pixels); + cmd.set_function(glesv2debugger::Message_Function_SKIP); + break; + default: + assert(0); //GenerateCall(msg, cmd); + break; + } + } +} diff --git a/opengl/libs/debug.in b/opengl/libs/debug.in new file mode 100644 index 0000000..882b2da --- /dev/null +++ b/opengl/libs/debug.in @@ -0,0 +1,235 @@ +// the following functions are not defined in GLESv2_dbg +TRACE_GL_VOID(glAlphaFunc, (GLenum func, GLclampf ref), (func, ref), 2, "GLenum", func, "GLclampf", ref) +TRACE_GL_VOID(glAlphaFuncx, (GLenum func, GLclampx ref), (func, ref), 2, "GLenum", func, "GLclampx", ref) +TRACE_GL_VOID(glAlphaFuncxOES, (GLenum func, GLclampx ref), (func, ref), 2, "GLenum", func, "GLclampx", ref) +TRACE_GL_VOID(glBeginPerfMonitorAMD, (GLuint monitor), (monitor), 1, "GLuint", monitor) +TRACE_GL_VOID(glBindFramebufferOES, (GLenum target, GLuint framebuffer), (target, framebuffer), 2, "GLenum", target, "GLuint", framebuffer) +TRACE_GL_VOID(glBindRenderbufferOES, (GLenum target, GLuint renderbuffer), (target, renderbuffer), 2, "GLenum", target, "GLuint", renderbuffer) +TRACE_GL_VOID(glBindVertexArrayOES, (GLuint array), (array), 1, "GLuint", array) +TRACE_GL_VOID(glBlendEquationOES, (GLenum mode), (mode), 1, "GLenum", mode) +TRACE_GL_VOID(glBlendEquationSeparateOES, (GLenum modeRGB, GLenum modeAlpha), (modeRGB, modeAlpha), 2, "GLenum", modeRGB, "GLenum", modeAlpha) +TRACE_GL_VOID(glBlendFuncSeparateOES, (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha), (srcRGB, dstRGB, srcAlpha, dstAlpha), 4, "GLenum", srcRGB, "GLenum", dstRGB, "GLenum", srcAlpha, "GLenum", dstAlpha) +TRACE_GL(GLenum, glCheckFramebufferStatusOES, (GLenum target), (target), 1, "GLenum", target) +TRACE_GL_VOID(glClearColorx, (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha), (red, green, blue, alpha), 4, "GLclampx", red, "GLclampx", green, "GLclampx", blue, "GLclampx", alpha) +TRACE_GL_VOID(glClearColorxOES, (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha), (red, green, blue, alpha), 4, "GLclampx", red, "GLclampx", green, "GLclampx", blue, "GLclampx", alpha) +TRACE_GL_VOID(glClearDepthfOES, (GLclampf depth), (depth), 1, "GLclampf", depth) +TRACE_GL_VOID(glClearDepthx, (GLclampx depth), (depth), 1, "GLclampx", depth) +TRACE_GL_VOID(glClearDepthxOES, (GLclampx depth), (depth), 1, "GLclampx", depth) +TRACE_GL_VOID(glClientActiveTexture, (GLenum texture), (texture), 1, "GLenum", texture) +TRACE_GL_VOID(glClipPlanef, (GLenum plane, const GLfloat *equation), (plane, equation), 2, "GLenum", plane, "const GLfloat *", equation) +TRACE_GL_VOID(glClipPlanefIMG, (GLenum p, const GLfloat *eqn), (p, eqn), 2, "GLenum", p, "const GLfloat *", eqn) +TRACE_GL_VOID(glClipPlanefOES, (GLenum plane, const GLfloat *equation), (plane, equation), 2, "GLenum", plane, "const GLfloat *", equation) +TRACE_GL_VOID(glClipPlanex, (GLenum plane, const GLfixed *equation), (plane, equation), 2, "GLenum", plane, "const GLfixed *", equation) +TRACE_GL_VOID(glClipPlanexIMG, (GLenum p, const GLfixed *eqn), (p, eqn), 2, "GLenum", p, "const GLfixed *", eqn) +TRACE_GL_VOID(glClipPlanexOES, (GLenum plane, const GLfixed *equation), (plane, equation), 2, "GLenum", plane, "const GLfixed *", equation) +TRACE_GL_VOID(glColor4f, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha), (red, green, blue, alpha), 4, "GLfloat", red, "GLfloat", green, "GLfloat", blue, "GLfloat", alpha) +TRACE_GL_VOID(glColor4ub, (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha), (red, green, blue, alpha), 4, "GLubyte", red, "GLubyte", green, "GLubyte", blue, "GLubyte", alpha) +TRACE_GL_VOID(glColor4x, (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha), (red, green, blue, alpha), 4, "GLfixed", red, "GLfixed", green, "GLfixed", blue, "GLfixed", alpha) +TRACE_GL_VOID(glColor4xOES, (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha), (red, green, blue, alpha), 4, "GLfixed", red, "GLfixed", green, "GLfixed", blue, "GLfixed", alpha) +TRACE_GL_VOID(glColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer), (size, type, stride, pointer), 4, "GLint", size, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glCompressedTexImage3DOES, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data), (target, level, internalformat, width, height, depth, border, imageSize, data), 9, "GLenum", target, "GLint", level, "GLenum", internalformat, "GLsizei", width, "GLsizei", height, "GLsizei", depth, "GLint", border, "GLsizei", imageSize, "const GLvoid*", data) +TRACE_GL_VOID(glCompressedTexSubImage3DOES, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data), (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), 11, "GLenum", target, "GLint", level, "GLint", xoffset, "GLint", yoffset, "GLint", zoffset, "GLsizei", width, "GLsizei", height, "GLsizei", depth, "GLenum", format, "GLsizei", imageSize, "const GLvoid*", data) +TRACE_GL_VOID(glCopyTexSubImage3DOES, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height), (target, level, xoffset, yoffset, zoffset, x, y, width, height), 9, "GLenum", target, "GLint", level, "GLint", xoffset, "GLint", yoffset, "GLint", zoffset, "GLint", x, "GLint", y, "GLsizei", width, "GLsizei", height) +TRACE_GL_VOID(glCoverageMaskNV, (GLboolean mask), (mask), 1, "GLboolean", mask) +TRACE_GL_VOID(glCoverageOperationNV, (GLenum operation), (operation), 1, "GLenum", operation) +TRACE_GL_VOID(glCurrentPaletteMatrixOES, (GLuint matrixpaletteindex), (matrixpaletteindex), 1, "GLuint", matrixpaletteindex) +TRACE_GL_VOID(glDeleteFencesNV, (GLsizei n, const GLuint *fences), (n, fences), 2, "GLsizei", n, "const GLuint *", fences) +TRACE_GL_VOID(glDeleteFramebuffersOES, (GLsizei n, const GLuint* framebuffers), (n, framebuffers), 2, "GLsizei", n, "const GLuint*", framebuffers) +TRACE_GL_VOID(glDeletePerfMonitorsAMD, (GLsizei n, GLuint *monitors), (n, monitors), 2, "GLsizei", n, "GLuint *", monitors) +TRACE_GL_VOID(glDeleteRenderbuffersOES, (GLsizei n, const GLuint* renderbuffers), (n, renderbuffers), 2, "GLsizei", n, "const GLuint*", renderbuffers) +TRACE_GL_VOID(glDeleteVertexArraysOES, (GLsizei n, const GLuint *arrays), (n, arrays), 2, "GLsizei", n, "const GLuint *", arrays) +TRACE_GL_VOID(glDepthRangefOES, (GLclampf zNear, GLclampf zFar), (zNear, zFar), 2, "GLclampf", zNear, "GLclampf", zFar) +TRACE_GL_VOID(glDepthRangex, (GLclampx zNear, GLclampx zFar), (zNear, zFar), 2, "GLclampx", zNear, "GLclampx", zFar) +TRACE_GL_VOID(glDepthRangexOES, (GLclampx zNear, GLclampx zFar), (zNear, zFar), 2, "GLclampx", zNear, "GLclampx", zFar) +TRACE_GL_VOID(glDisableClientState, (GLenum array), (array), 1, "GLenum", array) +TRACE_GL_VOID(glDisableDriverControlQCOM, (GLuint driverControl), (driverControl), 1, "GLuint", driverControl) +TRACE_GL_VOID(glDiscardFramebufferEXT, (GLenum target, GLsizei numAttachments, const GLenum *attachments), (target, numAttachments, attachments), 3, "GLenum", target, "GLsizei", numAttachments, "const GLenum *", attachments) +TRACE_GL_VOID(glDrawTexfOES, (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height), (x, y, z, width, height), 5, "GLfloat", x, "GLfloat", y, "GLfloat", z, "GLfloat", width, "GLfloat", height) +TRACE_GL_VOID(glDrawTexfvOES, (const GLfloat *coords), (coords), 1, "const GLfloat *", coords) +TRACE_GL_VOID(glDrawTexiOES, (GLint x, GLint y, GLint z, GLint width, GLint height), (x, y, z, width, height), 5, "GLint", x, "GLint", y, "GLint", z, "GLint", width, "GLint", height) +TRACE_GL_VOID(glDrawTexivOES, (const GLint *coords), (coords), 1, "const GLint *", coords) +TRACE_GL_VOID(glDrawTexsOES, (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height), (x, y, z, width, height), 5, "GLshort", x, "GLshort", y, "GLshort", z, "GLshort", width, "GLshort", height) +TRACE_GL_VOID(glDrawTexsvOES, (const GLshort *coords), (coords), 1, "const GLshort *", coords) +TRACE_GL_VOID(glDrawTexxOES, (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height), (x, y, z, width, height), 5, "GLfixed", x, "GLfixed", y, "GLfixed", z, "GLfixed", width, "GLfixed", height) +TRACE_GL_VOID(glDrawTexxvOES, (const GLfixed *coords), (coords), 1, "const GLfixed *", coords) +TRACE_GL_VOID(glEGLImageTargetRenderbufferStorageOES, (GLenum target, GLeglImageOES image), (target, image), 2, "GLenum", target, "GLeglImageOES", image) +TRACE_GL_VOID(glEGLImageTargetTexture2DOES, (GLenum target, GLeglImageOES image), (target, image), 2, "GLenum", target, "GLeglImageOES", image) +TRACE_GL_VOID(glEnableClientState, (GLenum array), (array), 1, "GLenum", array) +TRACE_GL_VOID(glEnableDriverControlQCOM, (GLuint driverControl), (driverControl), 1, "GLuint", driverControl) +TRACE_GL_VOID(glEndPerfMonitorAMD, (GLuint monitor), (monitor), 1, "GLuint", monitor) +TRACE_GL_VOID(glEndTilingQCOM, (GLbitfield preserveMask), (preserveMask), 1, "GLbitfield", preserveMask) +TRACE_GL_VOID(glExtGetBufferPointervQCOM, (GLenum target, GLvoid **params), (target, params), 2, "GLenum", target, "GLvoid **", params) +TRACE_GL_VOID(glExtGetBuffersQCOM, (GLuint *buffers, GLint maxBuffers, GLint *numBuffers), (buffers, maxBuffers, numBuffers), 3, "GLuint *", buffers, "GLint", maxBuffers, "GLint *", numBuffers) +TRACE_GL_VOID(glExtGetFramebuffersQCOM, (GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers), (framebuffers, maxFramebuffers, numFramebuffers), 3, "GLuint *", framebuffers, "GLint", maxFramebuffers, "GLint *", numFramebuffers) +TRACE_GL_VOID(glExtGetProgramBinarySourceQCOM, (GLuint program, GLenum shadertype, GLchar *source, GLint *length), (program, shadertype, source, length), 4, "GLuint", program, "GLenum", shadertype, "GLchar *", source, "GLint *", length) +TRACE_GL_VOID(glExtGetProgramsQCOM, (GLuint *programs, GLint maxPrograms, GLint *numPrograms), (programs, maxPrograms, numPrograms), 3, "GLuint *", programs, "GLint", maxPrograms, "GLint *", numPrograms) +TRACE_GL_VOID(glExtGetRenderbuffersQCOM, (GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers), (renderbuffers, maxRenderbuffers, numRenderbuffers), 3, "GLuint *", renderbuffers, "GLint", maxRenderbuffers, "GLint *", numRenderbuffers) +TRACE_GL_VOID(glExtGetShadersQCOM, (GLuint *shaders, GLint maxShaders, GLint *numShaders), (shaders, maxShaders, numShaders), 3, "GLuint *", shaders, "GLint", maxShaders, "GLint *", numShaders) +TRACE_GL_VOID(glExtGetTexLevelParameterivQCOM, (GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params), (texture, face, level, pname, params), 5, "GLuint", texture, "GLenum", face, "GLint", level, "GLenum", pname, "GLint *", params) +TRACE_GL_VOID(glExtGetTexSubImageQCOM, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels), (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels), 11, "GLenum", target, "GLint", level, "GLint", xoffset, "GLint", yoffset, "GLint", zoffset, "GLsizei", width, "GLsizei", height, "GLsizei", depth, "GLenum", format, "GLenum", type, "GLvoid *", texels) +TRACE_GL_VOID(glExtGetTexturesQCOM, (GLuint *textures, GLint maxTextures, GLint *numTextures), (textures, maxTextures, numTextures), 3, "GLuint *", textures, "GLint", maxTextures, "GLint *", numTextures) +TRACE_GL(GLboolean, glExtIsProgramBinaryQCOM, (GLuint program), (program), 1, "GLuint", program) +TRACE_GL_VOID(glExtTexObjectStateOverrideiQCOM, (GLenum target, GLenum pname, GLint param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLint", param) +TRACE_GL_VOID(glFinishFenceNV, (GLuint fence), (fence), 1, "GLuint", fence) +TRACE_GL_VOID(glFogf, (GLenum pname, GLfloat param), (pname, param), 2, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glFogfv, (GLenum pname, const GLfloat *params), (pname, params), 2, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glFogx, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glFogxOES, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glFogxv, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glFogxvOES, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glFramebufferRenderbufferOES, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer), (target, attachment, renderbuffertarget, renderbuffer), 4, "GLenum", target, "GLenum", attachment, "GLenum", renderbuffertarget, "GLuint", renderbuffer) +TRACE_GL_VOID(glFramebufferTexture2DMultisampleIMG, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples), (target, attachment, textarget, texture, level, samples), 6, "GLenum", target, "GLenum", attachment, "GLenum", textarget, "GLuint", texture, "GLint", level, "GLsizei", samples) +TRACE_GL_VOID(glFramebufferTexture2DOES, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level), (target, attachment, textarget, texture, level), 5, "GLenum", target, "GLenum", attachment, "GLenum", textarget, "GLuint", texture, "GLint", level) +TRACE_GL_VOID(glFramebufferTexture3DOES, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset), (target, attachment, textarget, texture, level, zoffset), 6, "GLenum", target, "GLenum", attachment, "GLenum", textarget, "GLuint", texture, "GLint", level, "GLint", zoffset) +TRACE_GL_VOID(glFrustumf, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfloat", left, "GLfloat", right, "GLfloat", bottom, "GLfloat", top, "GLfloat", zNear, "GLfloat", zFar) +TRACE_GL_VOID(glFrustumfOES, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfloat", left, "GLfloat", right, "GLfloat", bottom, "GLfloat", top, "GLfloat", zNear, "GLfloat", zFar) +TRACE_GL_VOID(glFrustumx, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfixed", left, "GLfixed", right, "GLfixed", bottom, "GLfixed", top, "GLfixed", zNear, "GLfixed", zFar) +TRACE_GL_VOID(glFrustumxOES, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfixed", left, "GLfixed", right, "GLfixed", bottom, "GLfixed", top, "GLfixed", zNear, "GLfixed", zFar) +TRACE_GL_VOID(glGenFencesNV, (GLsizei n, GLuint *fences), (n, fences), 2, "GLsizei", n, "GLuint *", fences) +TRACE_GL_VOID(glGenFramebuffersOES, (GLsizei n, GLuint* framebuffers), (n, framebuffers), 2, "GLsizei", n, "GLuint*", framebuffers) +TRACE_GL_VOID(glGenPerfMonitorsAMD, (GLsizei n, GLuint *monitors), (n, monitors), 2, "GLsizei", n, "GLuint *", monitors) +TRACE_GL_VOID(glGenRenderbuffersOES, (GLsizei n, GLuint* renderbuffers), (n, renderbuffers), 2, "GLsizei", n, "GLuint*", renderbuffers) +TRACE_GL_VOID(glGenVertexArraysOES, (GLsizei n, GLuint *arrays), (n, arrays), 2, "GLsizei", n, "GLuint *", arrays) +TRACE_GL_VOID(glGenerateMipmapOES, (GLenum target), (target), 1, "GLenum", target) +TRACE_GL_VOID(glGetBufferPointervOES, (GLenum target, GLenum pname, GLvoid ** params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "GLvoid **", params) +TRACE_GL_VOID(glGetClipPlanef, (GLenum pname, GLfloat eqn[4]), (pname, eqn), 2, "GLenum", pname, "GLfloat", eqn) +TRACE_GL_VOID(glGetClipPlanefOES, (GLenum pname, GLfloat eqn[4]), (pname, eqn), 2, "GLenum", pname, "GLfloat", eqn) +TRACE_GL_VOID(glGetClipPlanex, (GLenum pname, GLfixed eqn[4]), (pname, eqn), 2, "GLenum", pname, "GLfixed", eqn) +TRACE_GL_VOID(glGetClipPlanexOES, (GLenum pname, GLfixed eqn[4]), (pname, eqn), 2, "GLenum", pname, "GLfixed", eqn) +TRACE_GL_VOID(glGetDriverControlStringQCOM, (GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString), (driverControl, bufSize, length, driverControlString), 4, "GLuint", driverControl, "GLsizei", bufSize, "GLsizei *", length, "GLchar *", driverControlString) +TRACE_GL_VOID(glGetDriverControlsQCOM, (GLint *num, GLsizei size, GLuint *driverControls), (num, size, driverControls), 3, "GLint *", num, "GLsizei", size, "GLuint *", driverControls) +TRACE_GL_VOID(glGetFenceivNV, (GLuint fence, GLenum pname, GLint *params), (fence, pname, params), 3, "GLuint", fence, "GLenum", pname, "GLint *", params) +TRACE_GL_VOID(glGetFixedv, (GLenum pname, GLfixed *params), (pname, params), 2, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetFixedvOES, (GLenum pname, GLfixed *params), (pname, params), 2, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetFramebufferAttachmentParameterivOES, (GLenum target, GLenum attachment, GLenum pname, GLint* params), (target, attachment, pname, params), 4, "GLenum", target, "GLenum", attachment, "GLenum", pname, "GLint*", params) +TRACE_GL_VOID(glGetLightfv, (GLenum light, GLenum pname, GLfloat *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "GLfloat *", params) +TRACE_GL_VOID(glGetLightxv, (GLenum light, GLenum pname, GLfixed *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetLightxvOES, (GLenum light, GLenum pname, GLfixed *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetMaterialfv, (GLenum face, GLenum pname, GLfloat *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "GLfloat *", params) +TRACE_GL_VOID(glGetMaterialxv, (GLenum face, GLenum pname, GLfixed *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetMaterialxvOES, (GLenum face, GLenum pname, GLfixed *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetPerfMonitorCounterDataAMD, (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten), (monitor, pname, dataSize, data, bytesWritten), 5, "GLuint", monitor, "GLenum", pname, "GLsizei", dataSize, "GLuint *", data, "GLint *", bytesWritten) +TRACE_GL_VOID(glGetPerfMonitorCounterInfoAMD, (GLuint group, GLuint counter, GLenum pname, GLvoid *data), (group, counter, pname, data), 4, "GLuint", group, "GLuint", counter, "GLenum", pname, "GLvoid *", data) +TRACE_GL_VOID(glGetPerfMonitorCounterStringAMD, (GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString), (group, counter, bufSize, length, counterString), 5, "GLuint", group, "GLuint", counter, "GLsizei", bufSize, "GLsizei *", length, "GLchar *", counterString) +TRACE_GL_VOID(glGetPerfMonitorCountersAMD, (GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters), (group, numCounters, maxActiveCounters, counterSize, counters), 5, "GLuint", group, "GLint *", numCounters, "GLint *", maxActiveCounters, "GLsizei", counterSize, "GLuint *", counters) +TRACE_GL_VOID(glGetPerfMonitorGroupStringAMD, (GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString), (group, bufSize, length, groupString), 4, "GLuint", group, "GLsizei", bufSize, "GLsizei *", length, "GLchar *", groupString) +TRACE_GL_VOID(glGetPerfMonitorGroupsAMD, (GLint *numGroups, GLsizei groupsSize, GLuint *groups), (numGroups, groupsSize, groups), 3, "GLint *", numGroups, "GLsizei", groupsSize, "GLuint *", groups) +TRACE_GL_VOID(glGetPointerv, (GLenum pname, GLvoid **params), (pname, params), 2, "GLenum", pname, "GLvoid **", params) +TRACE_GL_VOID(glGetProgramBinaryOES, (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary), (program, bufSize, length, binaryFormat, binary), 5, "GLuint", program, "GLsizei", bufSize, "GLsizei *", length, "GLenum *", binaryFormat, "GLvoid *", binary) +TRACE_GL_VOID(glGetRenderbufferParameterivOES, (GLenum target, GLenum pname, GLint* params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "GLint*", params) +TRACE_GL_VOID(glGetTexEnvfv, (GLenum env, GLenum pname, GLfloat *params), (env, pname, params), 3, "GLenum", env, "GLenum", pname, "GLfloat *", params) +TRACE_GL_VOID(glGetTexEnviv, (GLenum env, GLenum pname, GLint *params), (env, pname, params), 3, "GLenum", env, "GLenum", pname, "GLint *", params) +TRACE_GL_VOID(glGetTexEnvxv, (GLenum env, GLenum pname, GLfixed *params), (env, pname, params), 3, "GLenum", env, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetTexEnvxvOES, (GLenum env, GLenum pname, GLfixed *params), (env, pname, params), 3, "GLenum", env, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetTexGenfvOES, (GLenum coord, GLenum pname, GLfloat *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "GLfloat *", params) +TRACE_GL_VOID(glGetTexGenivOES, (GLenum coord, GLenum pname, GLint *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "GLint *", params) +TRACE_GL_VOID(glGetTexGenxvOES, (GLenum coord, GLenum pname, GLfixed *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetTexParameterxv, (GLenum target, GLenum pname, GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "GLfixed *", params) +TRACE_GL_VOID(glGetTexParameterxvOES, (GLenum target, GLenum pname, GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "GLfixed *", params) +TRACE_GL(GLboolean, glIsFenceNV, (GLuint fence), (fence), 1, "GLuint", fence) +TRACE_GL(GLboolean, glIsFramebufferOES, (GLuint framebuffer), (framebuffer), 1, "GLuint", framebuffer) +TRACE_GL(GLboolean, glIsRenderbufferOES, (GLuint renderbuffer), (renderbuffer), 1, "GLuint", renderbuffer) +TRACE_GL(GLboolean, glIsVertexArrayOES, (GLuint array), (array), 1, "GLuint", array) +TRACE_GL_VOID(glLightModelf, (GLenum pname, GLfloat param), (pname, param), 2, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glLightModelfv, (GLenum pname, const GLfloat *params), (pname, params), 2, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glLightModelx, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glLightModelxOES, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glLightModelxv, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glLightModelxvOES, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glLightf, (GLenum light, GLenum pname, GLfloat param), (light, pname, param), 3, "GLenum", light, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glLightfv, (GLenum light, GLenum pname, const GLfloat *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glLightx, (GLenum light, GLenum pname, GLfixed param), (light, pname, param), 3, "GLenum", light, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glLightxOES, (GLenum light, GLenum pname, GLfixed param), (light, pname, param), 3, "GLenum", light, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glLightxv, (GLenum light, GLenum pname, const GLfixed *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glLightxvOES, (GLenum light, GLenum pname, const GLfixed *params), (light, pname, params), 3, "GLenum", light, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glLineWidthx, (GLfixed width), (width), 1, "GLfixed", width) +TRACE_GL_VOID(glLineWidthxOES, (GLfixed width), (width), 1, "GLfixed", width) +TRACE_GL_VOID(glLoadIdentity, (void), (), 0) +TRACE_GL_VOID(glLoadMatrixf, (const GLfloat *m), (m), 1, "const GLfloat *", m) +TRACE_GL_VOID(glLoadMatrixx, (const GLfixed *m), (m), 1, "const GLfixed *", m) +TRACE_GL_VOID(glLoadMatrixxOES, (const GLfixed *m), (m), 1, "const GLfixed *", m) +TRACE_GL_VOID(glLoadPaletteFromModelViewMatrixOES, (void), (), 0) +TRACE_GL_VOID(glLogicOp, (GLenum opcode), (opcode), 1, "GLenum", opcode) +TRACE_GL(void*, glMapBufferOES, (GLenum target, GLenum access), (target, access), 2, "GLenum", target, "GLenum", access) +TRACE_GL_VOID(glMaterialf, (GLenum face, GLenum pname, GLfloat param), (face, pname, param), 3, "GLenum", face, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glMaterialfv, (GLenum face, GLenum pname, const GLfloat *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glMaterialx, (GLenum face, GLenum pname, GLfixed param), (face, pname, param), 3, "GLenum", face, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glMaterialxOES, (GLenum face, GLenum pname, GLfixed param), (face, pname, param), 3, "GLenum", face, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glMaterialxv, (GLenum face, GLenum pname, const GLfixed *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glMaterialxvOES, (GLenum face, GLenum pname, const GLfixed *params), (face, pname, params), 3, "GLenum", face, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glMatrixIndexPointerOES, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer), (size, type, stride, pointer), 4, "GLint", size, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glMatrixMode, (GLenum mode), (mode), 1, "GLenum", mode) +TRACE_GL_VOID(glMultMatrixf, (const GLfloat *m), (m), 1, "const GLfloat *", m) +TRACE_GL_VOID(glMultMatrixx, (const GLfixed *m), (m), 1, "const GLfixed *", m) +TRACE_GL_VOID(glMultMatrixxOES, (const GLfixed *m), (m), 1, "const GLfixed *", m) +TRACE_GL_VOID(glMultiDrawArraysEXT, (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount), (mode, first, count, primcount), 4, "GLenum", mode, "GLint *", first, "GLsizei *", count, "GLsizei", primcount) +TRACE_GL_VOID(glMultiDrawElementsEXT, (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount), (mode, count, type, indices, primcount), 5, "GLenum", mode, "const GLsizei *", count, "GLenum", type, "const GLvoid* *", indices, "GLsizei", primcount) +TRACE_GL_VOID(glMultiTexCoord4f, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q), (target, s, t, r, q), 5, "GLenum", target, "GLfloat", s, "GLfloat", t, "GLfloat", r, "GLfloat", q) +TRACE_GL_VOID(glMultiTexCoord4x, (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q), (target, s, t, r, q), 5, "GLenum", target, "GLfixed", s, "GLfixed", t, "GLfixed", r, "GLfixed", q) +TRACE_GL_VOID(glMultiTexCoord4xOES, (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q), (target, s, t, r, q), 5, "GLenum", target, "GLfixed", s, "GLfixed", t, "GLfixed", r, "GLfixed", q) +TRACE_GL_VOID(glNormal3f, (GLfloat nx, GLfloat ny, GLfloat nz), (nx, ny, nz), 3, "GLfloat", nx, "GLfloat", ny, "GLfloat", nz) +TRACE_GL_VOID(glNormal3x, (GLfixed nx, GLfixed ny, GLfixed nz), (nx, ny, nz), 3, "GLfixed", nx, "GLfixed", ny, "GLfixed", nz) +TRACE_GL_VOID(glNormal3xOES, (GLfixed nx, GLfixed ny, GLfixed nz), (nx, ny, nz), 3, "GLfixed", nx, "GLfixed", ny, "GLfixed", nz) +TRACE_GL_VOID(glNormalPointer, (GLenum type, GLsizei stride, const GLvoid *pointer), (type, stride, pointer), 3, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glOrthof, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfloat", left, "GLfloat", right, "GLfloat", bottom, "GLfloat", top, "GLfloat", zNear, "GLfloat", zFar) +TRACE_GL_VOID(glOrthofOES, (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfloat", left, "GLfloat", right, "GLfloat", bottom, "GLfloat", top, "GLfloat", zNear, "GLfloat", zFar) +TRACE_GL_VOID(glOrthox, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfixed", left, "GLfixed", right, "GLfixed", bottom, "GLfixed", top, "GLfixed", zNear, "GLfixed", zFar) +TRACE_GL_VOID(glOrthoxOES, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar), (left, right, bottom, top, zNear, zFar), 6, "GLfixed", left, "GLfixed", right, "GLfixed", bottom, "GLfixed", top, "GLfixed", zNear, "GLfixed", zFar) +TRACE_GL_VOID(glPointParameterf, (GLenum pname, GLfloat param), (pname, param), 2, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glPointParameterfv, (GLenum pname, const GLfloat *params), (pname, params), 2, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glPointParameterx, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glPointParameterxOES, (GLenum pname, GLfixed param), (pname, param), 2, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glPointParameterxv, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glPointParameterxvOES, (GLenum pname, const GLfixed *params), (pname, params), 2, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glPointSize, (GLfloat size), (size), 1, "GLfloat", size) +TRACE_GL_VOID(glPointSizePointerOES, (GLenum type, GLsizei stride, const GLvoid *pointer), (type, stride, pointer), 3, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glPointSizex, (GLfixed size), (size), 1, "GLfixed", size) +TRACE_GL_VOID(glPointSizexOES, (GLfixed size), (size), 1, "GLfixed", size) +TRACE_GL_VOID(glPolygonOffsetx, (GLfixed factor, GLfixed units), (factor, units), 2, "GLfixed", factor, "GLfixed", units) +TRACE_GL_VOID(glPolygonOffsetxOES, (GLfixed factor, GLfixed units), (factor, units), 2, "GLfixed", factor, "GLfixed", units) +TRACE_GL_VOID(glPopMatrix, (void), (), 0) +TRACE_GL_VOID(glProgramBinaryOES, (GLuint program, GLenum binaryFormat, const GLvoid *binary, GLint length), (program, binaryFormat, binary, length), 4, "GLuint", program, "GLenum", binaryFormat, "const GLvoid *", binary, "GLint", length) +TRACE_GL_VOID(glPushMatrix, (void), (), 0) +TRACE_GL(GLbitfield, glQueryMatrixxOES, (GLfixed mantissa[16], GLint exponent[16]), (mantissa, exponent), 2, "GLfixed", mantissa, "GLint", exponent) +TRACE_GL_VOID(glRenderbufferStorageMultisampleIMG, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height), (target, samples, internalformat, width, height), 5, "GLenum", target, "GLsizei", samples, "GLenum", internalformat, "GLsizei", width, "GLsizei", height) +TRACE_GL_VOID(glRenderbufferStorageOES, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height), (target, internalformat, width, height), 4, "GLenum", target, "GLenum", internalformat, "GLsizei", width, "GLsizei", height) +TRACE_GL_VOID(glRotatef, (GLfloat angle, GLfloat x, GLfloat y, GLfloat z), (angle, x, y, z), 4, "GLfloat", angle, "GLfloat", x, "GLfloat", y, "GLfloat", z) +TRACE_GL_VOID(glRotatex, (GLfixed angle, GLfixed x, GLfixed y, GLfixed z), (angle, x, y, z), 4, "GLfixed", angle, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL_VOID(glRotatexOES, (GLfixed angle, GLfixed x, GLfixed y, GLfixed z), (angle, x, y, z), 4, "GLfixed", angle, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL_VOID(glSampleCoveragex, (GLclampx value, GLboolean invert), (value, invert), 2, "GLclampx", value, "GLboolean", invert) +TRACE_GL_VOID(glSampleCoveragexOES, (GLclampx value, GLboolean invert), (value, invert), 2, "GLclampx", value, "GLboolean", invert) +TRACE_GL_VOID(glScalef, (GLfloat x, GLfloat y, GLfloat z), (x, y, z), 3, "GLfloat", x, "GLfloat", y, "GLfloat", z) +TRACE_GL_VOID(glScalex, (GLfixed x, GLfixed y, GLfixed z), (x, y, z), 3, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL_VOID(glScalexOES, (GLfixed x, GLfixed y, GLfixed z), (x, y, z), 3, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL_VOID(glSelectPerfMonitorCountersAMD, (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList), (monitor, enable, group, numCounters, countersList), 5, "GLuint", monitor, "GLboolean", enable, "GLuint", group, "GLint", numCounters, "GLuint *", countersList) +TRACE_GL_VOID(glSetFenceNV, (GLuint fence, GLenum condition), (fence, condition), 2, "GLuint", fence, "GLenum", condition) +TRACE_GL_VOID(glShadeModel, (GLenum mode), (mode), 1, "GLenum", mode) +TRACE_GL_VOID(glStartTilingQCOM, (GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask), (x, y, width, height, preserveMask), 5, "GLuint", x, "GLuint", y, "GLuint", width, "GLuint", height, "GLbitfield", preserveMask) +TRACE_GL(GLboolean, glTestFenceNV, (GLuint fence), (fence), 1, "GLuint", fence) +TRACE_GL_VOID(glTexCoordPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer), (size, type, stride, pointer), 4, "GLint", size, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glTexEnvf, (GLenum target, GLenum pname, GLfloat param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glTexEnvfv, (GLenum target, GLenum pname, const GLfloat *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glTexEnvi, (GLenum target, GLenum pname, GLint param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLint", param) +TRACE_GL_VOID(glTexEnviv, (GLenum target, GLenum pname, const GLint *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLint *", params) +TRACE_GL_VOID(glTexEnvx, (GLenum target, GLenum pname, GLfixed param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glTexEnvxOES, (GLenum target, GLenum pname, GLfixed param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glTexEnvxv, (GLenum target, GLenum pname, const GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glTexEnvxvOES, (GLenum target, GLenum pname, const GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glTexGenfOES, (GLenum coord, GLenum pname, GLfloat param), (coord, pname, param), 3, "GLenum", coord, "GLenum", pname, "GLfloat", param) +TRACE_GL_VOID(glTexGenfvOES, (GLenum coord, GLenum pname, const GLfloat *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "const GLfloat *", params) +TRACE_GL_VOID(glTexGeniOES, (GLenum coord, GLenum pname, GLint param), (coord, pname, param), 3, "GLenum", coord, "GLenum", pname, "GLint", param) +TRACE_GL_VOID(glTexGenivOES, (GLenum coord, GLenum pname, const GLint *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "const GLint *", params) +TRACE_GL_VOID(glTexGenxOES, (GLenum coord, GLenum pname, GLfixed param), (coord, pname, param), 3, "GLenum", coord, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glTexGenxvOES, (GLenum coord, GLenum pname, const GLfixed *params), (coord, pname, params), 3, "GLenum", coord, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glTexImage3DOES, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels), (target, level, internalformat, width, height, depth, border, format, type, pixels), 10, "GLenum", target, "GLint", level, "GLenum", internalformat, "GLsizei", width, "GLsizei", height, "GLsizei", depth, "GLint", border, "GLenum", format, "GLenum", type, "const GLvoid*", pixels) +TRACE_GL_VOID(glTexParameterx, (GLenum target, GLenum pname, GLfixed param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glTexParameterxOES, (GLenum target, GLenum pname, GLfixed param), (target, pname, param), 3, "GLenum", target, "GLenum", pname, "GLfixed", param) +TRACE_GL_VOID(glTexParameterxv, (GLenum target, GLenum pname, const GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glTexParameterxvOES, (GLenum target, GLenum pname, const GLfixed *params), (target, pname, params), 3, "GLenum", target, "GLenum", pname, "const GLfixed *", params) +TRACE_GL_VOID(glTexSubImage3DOES, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels), (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), 11, "GLenum", target, "GLint", level, "GLint", xoffset, "GLint", yoffset, "GLint", zoffset, "GLsizei", width, "GLsizei", height, "GLsizei", depth, "GLenum", format, "GLenum", type, "const GLvoid*", pixels) +TRACE_GL_VOID(glTranslatef, (GLfloat x, GLfloat y, GLfloat z), (x, y, z), 3, "GLfloat", x, "GLfloat", y, "GLfloat", z) +TRACE_GL_VOID(glTranslatex, (GLfixed x, GLfixed y, GLfixed z), (x, y, z), 3, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL_VOID(glTranslatexOES, (GLfixed x, GLfixed y, GLfixed z), (x, y, z), 3, "GLfixed", x, "GLfixed", y, "GLfixed", z) +TRACE_GL(GLboolean, glUnmapBufferOES, (GLenum target), (target), 1, "GLenum", target) +TRACE_GL_VOID(glVertexPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer), (size, type, stride, pointer), 4, "GLint", size, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) +TRACE_GL_VOID(glWeightPointerOES, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer), (size, type, stride, pointer), 4, "GLint", size, "GLenum", type, "GLsizei", stride, "const GLvoid *", pointer) diff --git a/opengl/libs/glesv2dbg.h b/opengl/libs/glesv2dbg.h new file mode 100644 index 0000000..b988eb7 --- /dev/null +++ b/opengl/libs/glesv2dbg.h @@ -0,0 +1,32 @@ +/* + ** 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. + */ + +#ifndef _GLESV2_DBG_H_ +#define _GLESV2_DBG_H_ + +namespace android +{ + struct DbgContext; + + DbgContext * CreateDbgContext(const unsigned version, const gl_hooks_t * const hooks); + void DestroyDbgContext(DbgContext * const dbg); + + void StartDebugServer(); // create and bind socket if haven't already + void StopDebugServer(); // close socket if open + +}; // namespace android + +#endif // #ifndef _GLESV2_DBG_H_ diff --git a/opengl/libs/glesv2dbg_functions.h b/opengl/libs/glesv2dbg_functions.h new file mode 100644 index 0000000..2d70032 --- /dev/null +++ b/opengl/libs/glesv2dbg_functions.h @@ -0,0 +1,381 @@ +extern "C" +{ +GL_ENTRY(void, glActiveTexture, GLenum texture) +GL_ENTRY(void, glAlphaFunc, GLenum func, GLclampf ref) +GL_ENTRY(void, glAlphaFuncx, GLenum func, GLclampx ref) +GL_ENTRY(void, glAlphaFuncxOES, GLenum func, GLclampx ref) +GL_ENTRY(void, glAttachShader, GLuint program, GLuint shader) +GL_ENTRY(void, glBeginPerfMonitorAMD, GLuint monitor) +GL_ENTRY(void, glBindAttribLocation, GLuint program, GLuint index, const GLchar* name) +GL_ENTRY(void, glBindBuffer, GLenum target, GLuint buffer) +GL_ENTRY(void, glBindFramebuffer, GLenum target, GLuint framebuffer) +GL_ENTRY(void, glBindFramebufferOES, GLenum target, GLuint framebuffer) +GL_ENTRY(void, glBindRenderbuffer, GLenum target, GLuint renderbuffer) +GL_ENTRY(void, glBindRenderbufferOES, GLenum target, GLuint renderbuffer) +GL_ENTRY(void, glBindTexture, GLenum target, GLuint texture) +GL_ENTRY(void, glBindVertexArrayOES, GLuint array) +GL_ENTRY(void, glBlendColor, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +GL_ENTRY(void, glBlendEquation, GLenum mode ) +GL_ENTRY(void, glBlendEquationOES, GLenum mode) +GL_ENTRY(void, glBlendEquationSeparate, GLenum modeRGB, GLenum modeAlpha) +GL_ENTRY(void, glBlendEquationSeparateOES, GLenum modeRGB, GLenum modeAlpha) +GL_ENTRY(void, glBlendFunc, GLenum sfactor, GLenum dfactor) +GL_ENTRY(void, glBlendFuncSeparate, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +GL_ENTRY(void, glBlendFuncSeparateOES, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +GL_ENTRY(void, glBufferData, GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) +GL_ENTRY(void, glBufferSubData, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) +GL_ENTRY(GLenum, glCheckFramebufferStatus, GLenum target) +GL_ENTRY(GLenum, glCheckFramebufferStatusOES, GLenum target) +GL_ENTRY(void, glClear, GLbitfield mask) +GL_ENTRY(void, glClearColor, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +GL_ENTRY(void, glClearColorx, GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +GL_ENTRY(void, glClearColorxOES, GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +GL_ENTRY(void, glClearDepthf, GLclampf depth) +GL_ENTRY(void, glClearDepthfOES, GLclampf depth) +GL_ENTRY(void, glClearDepthx, GLclampx depth) +GL_ENTRY(void, glClearDepthxOES, GLclampx depth) +GL_ENTRY(void, glClearStencil, GLint s) +GL_ENTRY(void, glClientActiveTexture, GLenum texture) +GL_ENTRY(void, glClipPlanef, GLenum plane, const GLfloat *equation) +GL_ENTRY(void, glClipPlanefIMG, GLenum p, const GLfloat *eqn) +GL_ENTRY(void, glClipPlanefOES, GLenum plane, const GLfloat *equation) +GL_ENTRY(void, glClipPlanex, GLenum plane, const GLfixed *equation) +GL_ENTRY(void, glClipPlanexIMG, GLenum p, const GLfixed *eqn) +GL_ENTRY(void, glClipPlanexOES, GLenum plane, const GLfixed *equation) +GL_ENTRY(void, glColor4f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +GL_ENTRY(void, glColor4ub, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +GL_ENTRY(void, glColor4x, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +GL_ENTRY(void, glColor4xOES, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +GL_ENTRY(void, glColorMask, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +GL_ENTRY(void, glColorPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glCompileShader, GLuint shader) +GL_ENTRY(void, glCompressedTexImage2D, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) +GL_ENTRY(void, glCompressedTexImage3DOES, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +GL_ENTRY(void, glCompressedTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) +GL_ENTRY(void, glCompressedTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +GL_ENTRY(void, glCopyTexImage2D, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +GL_ENTRY(void, glCopyTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +GL_ENTRY(void, glCopyTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +GL_ENTRY(void, glCoverageMaskNV, GLboolean mask) +GL_ENTRY(void, glCoverageOperationNV, GLenum operation) +GL_ENTRY(GLuint, glCreateProgram, void) +GL_ENTRY(GLuint, glCreateShader, GLenum type) +GL_ENTRY(void, glCullFace, GLenum mode) +GL_ENTRY(void, glCurrentPaletteMatrixOES, GLuint matrixpaletteindex) +GL_ENTRY(void, glDeleteBuffers, GLsizei n, const GLuint *buffers) +GL_ENTRY(void, glDeleteFencesNV, GLsizei n, const GLuint *fences) +GL_ENTRY(void, glDeleteFramebuffers, GLsizei n, const GLuint* framebuffers) +GL_ENTRY(void, glDeleteFramebuffersOES, GLsizei n, const GLuint* framebuffers) +GL_ENTRY(void, glDeletePerfMonitorsAMD, GLsizei n, GLuint *monitors) +GL_ENTRY(void, glDeleteProgram, GLuint program) +GL_ENTRY(void, glDeleteRenderbuffers, GLsizei n, const GLuint* renderbuffers) +GL_ENTRY(void, glDeleteRenderbuffersOES, GLsizei n, const GLuint* renderbuffers) +GL_ENTRY(void, glDeleteShader, GLuint shader) +GL_ENTRY(void, glDeleteTextures, GLsizei n, const GLuint *textures) +GL_ENTRY(void, glDeleteVertexArraysOES, GLsizei n, const GLuint *arrays) +GL_ENTRY(void, glDepthFunc, GLenum func) +GL_ENTRY(void, glDepthMask, GLboolean flag) +GL_ENTRY(void, glDepthRangef, GLclampf zNear, GLclampf zFar) +GL_ENTRY(void, glDepthRangefOES, GLclampf zNear, GLclampf zFar) +GL_ENTRY(void, glDepthRangex, GLclampx zNear, GLclampx zFar) +GL_ENTRY(void, glDepthRangexOES, GLclampx zNear, GLclampx zFar) +GL_ENTRY(void, glDetachShader, GLuint program, GLuint shader) +GL_ENTRY(void, glDisable, GLenum cap) +GL_ENTRY(void, glDisableClientState, GLenum array) +GL_ENTRY(void, glDisableDriverControlQCOM, GLuint driverControl) +GL_ENTRY(void, glDisableVertexAttribArray, GLuint index) +GL_ENTRY(void, glDiscardFramebufferEXT, GLenum target, GLsizei numAttachments, const GLenum *attachments) +GL_ENTRY(void, glDrawArrays, GLenum mode, GLint first, GLsizei count) +GL_ENTRY(void, glDrawElements, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) +GL_ENTRY(void, glDrawTexfOES, GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) +GL_ENTRY(void, glDrawTexfvOES, const GLfloat *coords) +GL_ENTRY(void, glDrawTexiOES, GLint x, GLint y, GLint z, GLint width, GLint height) +GL_ENTRY(void, glDrawTexivOES, const GLint *coords) +GL_ENTRY(void, glDrawTexsOES, GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) +GL_ENTRY(void, glDrawTexsvOES, const GLshort *coords) +GL_ENTRY(void, glDrawTexxOES, GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) +GL_ENTRY(void, glDrawTexxvOES, const GLfixed *coords) +GL_ENTRY(void, glEGLImageTargetRenderbufferStorageOES, GLenum target, GLeglImageOES image) +GL_ENTRY(void, glEGLImageTargetTexture2DOES, GLenum target, GLeglImageOES image) +GL_ENTRY(void, glEnable, GLenum cap) +GL_ENTRY(void, glEnableClientState, GLenum array) +GL_ENTRY(void, glEnableDriverControlQCOM, GLuint driverControl) +GL_ENTRY(void, glEnableVertexAttribArray, GLuint index) +GL_ENTRY(void, glEndPerfMonitorAMD, GLuint monitor) +GL_ENTRY(void, glEndTilingQCOM, GLbitfield preserveMask) +GL_ENTRY(void, glExtGetBufferPointervQCOM, GLenum target, GLvoid **params) +GL_ENTRY(void, glExtGetBuffersQCOM, GLuint *buffers, GLint maxBuffers, GLint *numBuffers) +GL_ENTRY(void, glExtGetFramebuffersQCOM, GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) +GL_ENTRY(void, glExtGetProgramBinarySourceQCOM, GLuint program, GLenum shadertype, GLchar *source, GLint *length) +GL_ENTRY(void, glExtGetProgramsQCOM, GLuint *programs, GLint maxPrograms, GLint *numPrograms) +GL_ENTRY(void, glExtGetRenderbuffersQCOM, GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) +GL_ENTRY(void, glExtGetShadersQCOM, GLuint *shaders, GLint maxShaders, GLint *numShaders) +GL_ENTRY(void, glExtGetTexLevelParameterivQCOM, GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) +GL_ENTRY(void, glExtGetTexSubImageQCOM, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) +GL_ENTRY(void, glExtGetTexturesQCOM, GLuint *textures, GLint maxTextures, GLint *numTextures) +GL_ENTRY(GLboolean, glExtIsProgramBinaryQCOM, GLuint program) +GL_ENTRY(void, glExtTexObjectStateOverrideiQCOM, GLenum target, GLenum pname, GLint param) +GL_ENTRY(void, glFinish, void) +GL_ENTRY(void, glFinishFenceNV, GLuint fence) +GL_ENTRY(void, glFlush, void) +GL_ENTRY(void, glFogf, GLenum pname, GLfloat param) +GL_ENTRY(void, glFogfv, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glFogx, GLenum pname, GLfixed param) +GL_ENTRY(void, glFogxOES, GLenum pname, GLfixed param) +GL_ENTRY(void, glFogxv, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glFogxvOES, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glFramebufferRenderbuffer, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +GL_ENTRY(void, glFramebufferRenderbufferOES, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +GL_ENTRY(void, glFramebufferTexture2D, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +GL_ENTRY(void, glFramebufferTexture2DMultisampleIMG, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) +GL_ENTRY(void, glFramebufferTexture2DOES, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +GL_ENTRY(void, glFramebufferTexture3DOES, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +GL_ENTRY(void, glFrontFace, GLenum mode) +GL_ENTRY(void, glFrustumf, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +GL_ENTRY(void, glFrustumfOES, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +GL_ENTRY(void, glFrustumx, GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +GL_ENTRY(void, glFrustumxOES, GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +GL_ENTRY(void, glGenBuffers, GLsizei n, GLuint *buffers) +GL_ENTRY(void, glGenFencesNV, GLsizei n, GLuint *fences) +GL_ENTRY(void, glGenFramebuffers, GLsizei n, GLuint* framebuffers) +GL_ENTRY(void, glGenFramebuffersOES, GLsizei n, GLuint* framebuffers) +GL_ENTRY(void, glGenPerfMonitorsAMD, GLsizei n, GLuint *monitors) +GL_ENTRY(void, glGenRenderbuffers, GLsizei n, GLuint* renderbuffers) +GL_ENTRY(void, glGenRenderbuffersOES, GLsizei n, GLuint* renderbuffers) +GL_ENTRY(void, glGenTextures, GLsizei n, GLuint *textures) +GL_ENTRY(void, glGenVertexArraysOES, GLsizei n, GLuint *arrays) +GL_ENTRY(void, glGenerateMipmap, GLenum target) +GL_ENTRY(void, glGenerateMipmapOES, GLenum target) +GL_ENTRY(void, glGetActiveAttrib, GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +GL_ENTRY(void, glGetActiveUniform, GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +GL_ENTRY(void, glGetAttachedShaders, GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) +GL_ENTRY(int, glGetAttribLocation, GLuint program, const GLchar* name) +GL_ENTRY(void, glGetBooleanv, GLenum pname, GLboolean *params) +GL_ENTRY(void, glGetBufferParameteriv, GLenum target, GLenum pname, GLint *params) +GL_ENTRY(void, glGetBufferPointervOES, GLenum target, GLenum pname, GLvoid ** params) +GL_ENTRY(void, glGetClipPlanef, GLenum pname, GLfloat eqn[4]) +GL_ENTRY(void, glGetClipPlanefOES, GLenum pname, GLfloat eqn[4]) +GL_ENTRY(void, glGetClipPlanex, GLenum pname, GLfixed eqn[4]) +GL_ENTRY(void, glGetClipPlanexOES, GLenum pname, GLfixed eqn[4]) +GL_ENTRY(void, glGetDriverControlStringQCOM, GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) +GL_ENTRY(void, glGetDriverControlsQCOM, GLint *num, GLsizei size, GLuint *driverControls) +GL_ENTRY(GLenum, glGetError, void) +GL_ENTRY(void, glGetFenceivNV, GLuint fence, GLenum pname, GLint *params) +GL_ENTRY(void, glGetFixedv, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetFixedvOES, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetFloatv, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetFramebufferAttachmentParameteriv, GLenum target, GLenum attachment, GLenum pname, GLint* params) +GL_ENTRY(void, glGetFramebufferAttachmentParameterivOES, GLenum target, GLenum attachment, GLenum pname, GLint* params) +GL_ENTRY(void, glGetIntegerv, GLenum pname, GLint *params) +GL_ENTRY(void, glGetLightfv, GLenum light, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetLightxv, GLenum light, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetLightxvOES, GLenum light, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetMaterialfv, GLenum face, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetMaterialxv, GLenum face, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetMaterialxvOES, GLenum face, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetPerfMonitorCounterDataAMD, GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten) +GL_ENTRY(void, glGetPerfMonitorCounterInfoAMD, GLuint group, GLuint counter, GLenum pname, GLvoid *data) +GL_ENTRY(void, glGetPerfMonitorCounterStringAMD, GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString) +GL_ENTRY(void, glGetPerfMonitorCountersAMD, GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters) +GL_ENTRY(void, glGetPerfMonitorGroupStringAMD, GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString) +GL_ENTRY(void, glGetPerfMonitorGroupsAMD, GLint *numGroups, GLsizei groupsSize, GLuint *groups) +GL_ENTRY(void, glGetPointerv, GLenum pname, GLvoid **params) +GL_ENTRY(void, glGetProgramBinaryOES, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary) +GL_ENTRY(void, glGetProgramInfoLog, GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) +GL_ENTRY(void, glGetProgramiv, GLuint program, GLenum pname, GLint* params) +GL_ENTRY(void, glGetRenderbufferParameteriv, GLenum target, GLenum pname, GLint* params) +GL_ENTRY(void, glGetRenderbufferParameterivOES, GLenum target, GLenum pname, GLint* params) +GL_ENTRY(void, glGetShaderInfoLog, GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) +GL_ENTRY(void, glGetShaderPrecisionFormat, GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) +GL_ENTRY(void, glGetShaderSource, GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) +GL_ENTRY(void, glGetShaderiv, GLuint shader, GLenum pname, GLint* params) +GL_ENTRY(const GLubyte *, glGetString, GLenum name) +GL_ENTRY(void, glGetTexEnvfv, GLenum env, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetTexEnviv, GLenum env, GLenum pname, GLint *params) +GL_ENTRY(void, glGetTexEnvxv, GLenum env, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetTexEnvxvOES, GLenum env, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetTexGenfvOES, GLenum coord, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetTexGenivOES, GLenum coord, GLenum pname, GLint *params) +GL_ENTRY(void, glGetTexGenxvOES, GLenum coord, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetTexParameterfv, GLenum target, GLenum pname, GLfloat *params) +GL_ENTRY(void, glGetTexParameteriv, GLenum target, GLenum pname, GLint *params) +GL_ENTRY(void, glGetTexParameterxv, GLenum target, GLenum pname, GLfixed *params) +GL_ENTRY(void, glGetTexParameterxvOES, GLenum target, GLenum pname, GLfixed *params) +GL_ENTRY(int, glGetUniformLocation, GLuint program, const GLchar* name) +GL_ENTRY(void, glGetUniformfv, GLuint program, GLint location, GLfloat* params) +GL_ENTRY(void, glGetUniformiv, GLuint program, GLint location, GLint* params) +GL_ENTRY(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, GLvoid** pointer) +GL_ENTRY(void, glGetVertexAttribfv, GLuint index, GLenum pname, GLfloat* params) +GL_ENTRY(void, glGetVertexAttribiv, GLuint index, GLenum pname, GLint* params) +GL_ENTRY(void, glHint, GLenum target, GLenum mode) +GL_ENTRY(GLboolean, glIsBuffer, GLuint buffer) +GL_ENTRY(GLboolean, glIsEnabled, GLenum cap) +GL_ENTRY(GLboolean, glIsFenceNV, GLuint fence) +GL_ENTRY(GLboolean, glIsFramebuffer, GLuint framebuffer) +GL_ENTRY(GLboolean, glIsFramebufferOES, GLuint framebuffer) +GL_ENTRY(GLboolean, glIsProgram, GLuint program) +GL_ENTRY(GLboolean, glIsRenderbuffer, GLuint renderbuffer) +GL_ENTRY(GLboolean, glIsRenderbufferOES, GLuint renderbuffer) +GL_ENTRY(GLboolean, glIsShader, GLuint shader) +GL_ENTRY(GLboolean, glIsTexture, GLuint texture) +GL_ENTRY(GLboolean, glIsVertexArrayOES, GLuint array) +GL_ENTRY(void, glLightModelf, GLenum pname, GLfloat param) +GL_ENTRY(void, glLightModelfv, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glLightModelx, GLenum pname, GLfixed param) +GL_ENTRY(void, glLightModelxOES, GLenum pname, GLfixed param) +GL_ENTRY(void, glLightModelxv, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glLightModelxvOES, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glLightf, GLenum light, GLenum pname, GLfloat param) +GL_ENTRY(void, glLightfv, GLenum light, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glLightx, GLenum light, GLenum pname, GLfixed param) +GL_ENTRY(void, glLightxOES, GLenum light, GLenum pname, GLfixed param) +GL_ENTRY(void, glLightxv, GLenum light, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glLightxvOES, GLenum light, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glLineWidth, GLfloat width) +GL_ENTRY(void, glLineWidthx, GLfixed width) +GL_ENTRY(void, glLineWidthxOES, GLfixed width) +GL_ENTRY(void, glLinkProgram, GLuint program) +GL_ENTRY(void, glLoadIdentity, void) +GL_ENTRY(void, glLoadMatrixf, const GLfloat *m) +GL_ENTRY(void, glLoadMatrixx, const GLfixed *m) +GL_ENTRY(void, glLoadMatrixxOES, const GLfixed *m) +GL_ENTRY(void, glLoadPaletteFromModelViewMatrixOES, void) +GL_ENTRY(void, glLogicOp, GLenum opcode) +GL_ENTRY(void*, glMapBufferOES, GLenum target, GLenum access) +GL_ENTRY(void, glMaterialf, GLenum face, GLenum pname, GLfloat param) +GL_ENTRY(void, glMaterialfv, GLenum face, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glMaterialx, GLenum face, GLenum pname, GLfixed param) +GL_ENTRY(void, glMaterialxOES, GLenum face, GLenum pname, GLfixed param) +GL_ENTRY(void, glMaterialxv, GLenum face, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glMaterialxvOES, GLenum face, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glMatrixIndexPointerOES, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glMatrixMode, GLenum mode) +GL_ENTRY(void, glMultMatrixf, const GLfloat *m) +GL_ENTRY(void, glMultMatrixx, const GLfixed *m) +GL_ENTRY(void, glMultMatrixxOES, const GLfixed *m) +GL_ENTRY(void, glMultiDrawArraysEXT, GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) +GL_ENTRY(void, glMultiDrawElementsEXT, GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) +GL_ENTRY(void, glMultiTexCoord4f, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +GL_ENTRY(void, glMultiTexCoord4x, GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +GL_ENTRY(void, glMultiTexCoord4xOES, GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +GL_ENTRY(void, glNormal3f, GLfloat nx, GLfloat ny, GLfloat nz) +GL_ENTRY(void, glNormal3x, GLfixed nx, GLfixed ny, GLfixed nz) +GL_ENTRY(void, glNormal3xOES, GLfixed nx, GLfixed ny, GLfixed nz) +GL_ENTRY(void, glNormalPointer, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glOrthof, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +GL_ENTRY(void, glOrthofOES, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +GL_ENTRY(void, glOrthox, GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +GL_ENTRY(void, glOrthoxOES, GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +GL_ENTRY(void, glPixelStorei, GLenum pname, GLint param) +GL_ENTRY(void, glPointParameterf, GLenum pname, GLfloat param) +GL_ENTRY(void, glPointParameterfv, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glPointParameterx, GLenum pname, GLfixed param) +GL_ENTRY(void, glPointParameterxOES, GLenum pname, GLfixed param) +GL_ENTRY(void, glPointParameterxv, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glPointParameterxvOES, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glPointSize, GLfloat size) +GL_ENTRY(void, glPointSizePointerOES, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glPointSizex, GLfixed size) +GL_ENTRY(void, glPointSizexOES, GLfixed size) +GL_ENTRY(void, glPolygonOffset, GLfloat factor, GLfloat units) +GL_ENTRY(void, glPolygonOffsetx, GLfixed factor, GLfixed units) +GL_ENTRY(void, glPolygonOffsetxOES, GLfixed factor, GLfixed units) +GL_ENTRY(void, glPopMatrix, void) +GL_ENTRY(void, glProgramBinaryOES, GLuint program, GLenum binaryFormat, const GLvoid *binary, GLint length) +GL_ENTRY(void, glPushMatrix, void) +GL_ENTRY(GLbitfield, glQueryMatrixxOES, GLfixed mantissa[16], GLint exponent[16]) +GL_ENTRY(void, glReadPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) +GL_ENTRY(void, glReleaseShaderCompiler, void) +GL_ENTRY(void, glRenderbufferStorage, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +GL_ENTRY(void, glRenderbufferStorageMultisampleIMG, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) +GL_ENTRY(void, glRenderbufferStorageOES, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +GL_ENTRY(void, glRotatef, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +GL_ENTRY(void, glRotatex, GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glRotatexOES, GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glSampleCoverage, GLclampf value, GLboolean invert) +GL_ENTRY(void, glSampleCoveragex, GLclampx value, GLboolean invert) +GL_ENTRY(void, glSampleCoveragexOES, GLclampx value, GLboolean invert) +GL_ENTRY(void, glScalef, GLfloat x, GLfloat y, GLfloat z) +GL_ENTRY(void, glScalex, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glScalexOES, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glScissor, GLint x, GLint y, GLsizei width, GLsizei height) +GL_ENTRY(void, glSelectPerfMonitorCountersAMD, GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList) +GL_ENTRY(void, glSetFenceNV, GLuint fence, GLenum condition) +GL_ENTRY(void, glShadeModel, GLenum mode) +GL_ENTRY(void, glShaderBinary, GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) +GL_ENTRY(void, glShaderSource, GLuint shader, GLsizei count, const GLchar** string, const GLint* length) +GL_ENTRY(void, glStartTilingQCOM, GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) +GL_ENTRY(void, glStencilFunc, GLenum func, GLint ref, GLuint mask) +GL_ENTRY(void, glStencilFuncSeparate, GLenum face, GLenum func, GLint ref, GLuint mask) +GL_ENTRY(void, glStencilMask, GLuint mask) +GL_ENTRY(void, glStencilMaskSeparate, GLenum face, GLuint mask) +GL_ENTRY(void, glStencilOp, GLenum fail, GLenum zfail, GLenum zpass) +GL_ENTRY(void, glStencilOpSeparate, GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +GL_ENTRY(GLboolean, glTestFenceNV, GLuint fence) +GL_ENTRY(void, glTexCoordPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glTexEnvf, GLenum target, GLenum pname, GLfloat param) +GL_ENTRY(void, glTexEnvfv, GLenum target, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glTexEnvi, GLenum target, GLenum pname, GLint param) +GL_ENTRY(void, glTexEnviv, GLenum target, GLenum pname, const GLint *params) +GL_ENTRY(void, glTexEnvx, GLenum target, GLenum pname, GLfixed param) +GL_ENTRY(void, glTexEnvxOES, GLenum target, GLenum pname, GLfixed param) +GL_ENTRY(void, glTexEnvxv, GLenum target, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glTexEnvxvOES, GLenum target, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glTexGenfOES, GLenum coord, GLenum pname, GLfloat param) +GL_ENTRY(void, glTexGenfvOES, GLenum coord, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glTexGeniOES, GLenum coord, GLenum pname, GLint param) +GL_ENTRY(void, glTexGenivOES, GLenum coord, GLenum pname, const GLint *params) +GL_ENTRY(void, glTexGenxOES, GLenum coord, GLenum pname, GLfixed param) +GL_ENTRY(void, glTexGenxvOES, GLenum coord, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glTexImage2D, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) +GL_ENTRY(void, glTexImage3DOES, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) +GL_ENTRY(void, glTexParameterf, GLenum target, GLenum pname, GLfloat param) +GL_ENTRY(void, glTexParameterfv, GLenum target, GLenum pname, const GLfloat *params) +GL_ENTRY(void, glTexParameteri, GLenum target, GLenum pname, GLint param) +GL_ENTRY(void, glTexParameteriv, GLenum target, GLenum pname, const GLint *params) +GL_ENTRY(void, glTexParameterx, GLenum target, GLenum pname, GLfixed param) +GL_ENTRY(void, glTexParameterxOES, GLenum target, GLenum pname, GLfixed param) +GL_ENTRY(void, glTexParameterxv, GLenum target, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glTexParameterxvOES, GLenum target, GLenum pname, const GLfixed *params) +GL_ENTRY(void, glTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +GL_ENTRY(void, glTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) +GL_ENTRY(void, glTranslatef, GLfloat x, GLfloat y, GLfloat z) +GL_ENTRY(void, glTranslatex, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glTranslatexOES, GLfixed x, GLfixed y, GLfixed z) +GL_ENTRY(void, glUniform1f, GLint location, GLfloat x) +GL_ENTRY(void, glUniform1fv, GLint location, GLsizei count, const GLfloat* v) +GL_ENTRY(void, glUniform1i, GLint location, GLint x) +GL_ENTRY(void, glUniform1iv, GLint location, GLsizei count, const GLint* v) +GL_ENTRY(void, glUniform2f, GLint location, GLfloat x, GLfloat y) +GL_ENTRY(void, glUniform2fv, GLint location, GLsizei count, const GLfloat* v) +GL_ENTRY(void, glUniform2i, GLint location, GLint x, GLint y) +GL_ENTRY(void, glUniform2iv, GLint location, GLsizei count, const GLint* v) +GL_ENTRY(void, glUniform3f, GLint location, GLfloat x, GLfloat y, GLfloat z) +GL_ENTRY(void, glUniform3fv, GLint location, GLsizei count, const GLfloat* v) +GL_ENTRY(void, glUniform3i, GLint location, GLint x, GLint y, GLint z) +GL_ENTRY(void, glUniform3iv, GLint location, GLsizei count, const GLint* v) +GL_ENTRY(void, glUniform4f, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +GL_ENTRY(void, glUniform4fv, GLint location, GLsizei count, const GLfloat* v) +GL_ENTRY(void, glUniform4i, GLint location, GLint x, GLint y, GLint z, GLint w) +GL_ENTRY(void, glUniform4iv, GLint location, GLsizei count, const GLint* v) +GL_ENTRY(void, glUniformMatrix2fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +GL_ENTRY(void, glUniformMatrix3fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +GL_ENTRY(void, glUniformMatrix4fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +GL_ENTRY(GLboolean, glUnmapBufferOES, GLenum target) +GL_ENTRY(void, glUseProgram, GLuint program) +GL_ENTRY(void, glValidateProgram, GLuint program) +GL_ENTRY(void, glVertexAttrib1f, GLuint indx, GLfloat x) +GL_ENTRY(void, glVertexAttrib1fv, GLuint indx, const GLfloat* values) +GL_ENTRY(void, glVertexAttrib2f, GLuint indx, GLfloat x, GLfloat y) +GL_ENTRY(void, glVertexAttrib2fv, GLuint indx, const GLfloat* values) +GL_ENTRY(void, glVertexAttrib3f, GLuint indx, GLfloat x, GLfloat y, GLfloat z) +GL_ENTRY(void, glVertexAttrib3fv, GLuint indx, const GLfloat* values) +GL_ENTRY(void, glVertexAttrib4f, GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +GL_ENTRY(void, glVertexAttrib4fv, GLuint indx, const GLfloat* values) +GL_ENTRY(void, glVertexAttribPointer, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) +GL_ENTRY(void, glVertexPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +GL_ENTRY(void, glViewport, GLint x, GLint y, GLsizei width, GLsizei height) +GL_ENTRY(void, glWeightPointerOES, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + + +} |