Initial commit of GLESv2 debugger server

Use debug.egl.debug_proc property to match process cmdline.
Binds to TCP:5039 and waits for client connection.
Sends function call parameters, textures and shaders using Protobuf.
Java Eclipse client plug-in is next.

Change-Id: I183b755263663f87e86dde1ad12f527d0445fd57
Signed-off-by: David Li <davidxli@google.com>

21 files changed, 9995 insertions, 7 deletions

diff --git a/opengl/libs/Android.mk b/opengl/libs/Android.mk
index c8041fc..f1afbb6 100644
--- a/opengl/libs/Android.mk
+++ b/opengl/libs/Android.mk
@@ -13,8 +13,8 @@ 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
 
@@ -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..55b5436 100644
--- a/opengl/libs/EGL/Loader.cpp
+++ b/opengl/libs/EGL/Loader.cpp
@@ -114,6 +114,8 @@ Loader::Loader()
 
 Loader::~Loader()
 {
+    extern void StopDebugServer();
+    StopDebugServer();
 }
 
 const char* Loader::getTag(int dpy, int impl)
diff --git a/opengl/libs/EGL/egl.cpp b/opengl/libs/EGL/egl.cpp
index 3d5a4d1..e427504 100644
--- a/opengl/libs/EGL/egl.cpp
+++ b/opengl/libs/EGL/egl.cpp
@@ -296,9 +296,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 +314,37 @@ 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))
+        {
+            LOGD("\n*\n*\n* initEglTraceLevel cmdline='%s' \n*\n*", cmdline);
+            if (!strcmp(value, cmdline))
+                gEGLDebugLevel = 1;
+        }    
+        fclose(file);
+    }
+    
+    extern void StartDebugServer();
+    if (gEGLDebugLevel > 0)
+        StartDebugServer();
 }
 
 static void setGLHooksThreadSpecific(gl_hooks_t const *value) {
     if (gEGLTraceLevel > 0) {
         setGlTraceThreadSpecific(value);
         setGlThreadSpecific(&gHooksTrace);
+    } else if (gEGLDebugLevel > 0) {
+        setGlTraceThreadSpecific(value);
+        setGlThreadSpecific(&gHooksDebug);
+        LOGD("\n* setGLHooksThreadSpecific gHooksDebug");
     } else {
         setGlThreadSpecific(value);
     }
@@ -1597,7 +1622,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);
                 }
diff --git a/opengl/libs/EGL/trace.cpp b/opengl/libs/EGL/trace.cpp
index d3e96ba..3a1ae21 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 "../GLES2_dbg/include/glesv2_dbg.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..c919886
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/Android.mk
@@ -0,0 +1,46 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    src/DebuggerMessage.pb.cpp \
+    src/api.cpp \
+    src/server.cpp \
+    src/shader.cpp \
+    src/texture.cpp
+
+LOCAL_C_INCLUDES :=	\
+    $(LOCAL_PATH) \
+    $(LOCAL_PATH)/../ \
+    external/stlport/stlport \
+    external/protobuf/src \
+    bionic
+
+LOCAL_SHARED_LIBRARIES := libstlport libcutils libutils
+LOCAL_LDLIBS := -lpthread
+
+#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_DebuggerMessage_proto.py b/opengl/libs/GLES2_dbg/generate_DebuggerMessage_proto.py
new file mode 100755
index 0000000..a803fae
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_DebuggerMessage_proto.py
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+def generate_DebuggerMessage(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("\t\t%s = %d;\n" % (line, i))
+			i += 1
+	return i
+
+
+if __name__ == "__main__":
+	output = open("DebuggerMessage.proto",'w')
+	output.write( """// do not edit; auto generated by generate_DebuggerMessage_proto.py
+package GLESv2Debugger;
+
+option optimize_for = LITE_RUNTIME;
+
+message Message
+{
+\trequired int32 context_id = 1; // GL context id
+\tenum Function
+\t{
+""")
+
+	i = 0;
+	
+	lines = open("gl2_api.in").readlines()
+	i = generate_DebuggerMessage(output, lines, i)
+	output.write("\t\t// end of GL functions\n")
+	
+	#lines = open("gl2ext_api.in").readlines()
+	#i = generate_DebuggerMessage(output, lines, i)
+	#output.write("\t\t// end of GL EXT functions\n")
+	
+	output.write("\t\tACK = %d;\n" % (i))
+	i += 1
+	
+	output.write("\t\tNEG = %d;\n" % (i))
+	i += 1
+	
+	output.write("\t\tCONTINUE = %d;\n" % (i))
+	i += 1
+	
+	output.write("\t\tSKIP = %d;\n" % (i))
+	i += 1
+	
+	output.write("""\t}
+\trequired Function function = 2 [default = NEG]; // type/function of message
+\trequired bool has_next_message = 3;
+\trequired bool expect_response = 4;
+\toptional int32 ret = 5; // return value from previous GL call
+\toptional int32 arg0 = 6; // args to GL call
+\toptional int32 arg1 = 7;
+\toptional int32 arg2 = 8;
+\toptional int32 arg3 = 9;
+\toptional int32 arg4 = 16;
+\toptional int32 arg5 = 17;
+\toptional int32 arg6 = 18;
+\toptional int32 arg7 = 19;
+\toptional int32 arg8 = 20;
+\toptional bytes data = 10; // variable length data used for GL call
+\toptional float time = 11; // timing of previous GL call (seconds)
+}
+""")
+
+	output.close()
+	
+	os.system("aprotoc --cpp_out=src --java_out=client/src DebuggerMessage.proto")
+	os.system(' mv -f "src/DebuggerMessage.pb.cc" "src/DebuggerMessage.pb.cpp" ')
diff --git a/opengl/libs/GLES2_dbg/generate_GLEnum_java.py b/opengl/libs/GLES2_dbg/generate_GLEnum_java.py
new file mode 100755
index 0000000..f927422
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_GLEnum_java.py
@@ -0,0 +1,43 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+if __name__ == "__main__":
+	externs = []
+	lines = open("enums.in").readlines()
+	i = 0
+	print "// auto generated by generate_GLFunction_java.py"
+	print """package GLESv2Debugger;
+
+public enum GLEnum
+{"""
+	
+	index = 0
+	for line in lines:
+		value = line[line.find("(") + 1: line.find(",")]
+		name = line[line.find(",") + 1: line.find(")")]	
+		print "\t%s(%s)," % (name, value)
+
+	print """\t;
+
+\tpublic final int value;
+\tGLEnum(final int value)
+\t{
+\t\tthis.value = value;
+\t}
+
+\tprivate static final java.util.HashMap<Integer, GLEnum> reverseMap = new java.util.HashMap<Integer, GLEnum>();
+\tstatic 
+\t{
+\t\tfor (GLEnum e : GLEnum.values())
+\t\t\treverseMap.put(e.value, e);
+\t}
+
+\tpublic static GLEnum valueOf(final int value)
+\t{
+\t\treturn reverseMap.get(value);
+\t}
+}"""
+
+
diff --git a/opengl/libs/GLES2_dbg/generate_GLFunction_java.py b/opengl/libs/GLES2_dbg/generate_GLFunction_java.py
new file mode 100755
index 0000000..07bbf14
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_GLFunction_java.py
@@ -0,0 +1,34 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+if __name__ == "__main__":
+	externs = []
+	lines = open("gl2_api.in").readlines()
+	i = 0
+	print "// auto generated by generate_GLFunction_java.py"
+	print """package GLESv2Debugger;
+
+public enum GLFunction
+{"""
+	
+	index = 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
+			print "\t%s(%d, DebuggerMessage.Message.Function.%s)," % (functionName, index, functionName)
+			index += 1
+	print """\t;
+
+\tpublic final int index;
+\tpublic final DebuggerMessage.Message.Function function;
+\tGLFunction(final int index, final DebuggerMessage.Message.Function function)
+\t{
+\t\tthis.index = index;
+\t\tthis.function = function;
+\t}
+}"""
+			
+
diff --git a/opengl/libs/GLES2_dbg/generate_MessageFormatter_java.py b/opengl/libs/GLES2_dbg/generate_MessageFormatter_java.py
new file mode 100755
index 0000000..81272e6
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_MessageFormatter_java.py
@@ -0,0 +1,239 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+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
+		
+if __name__ == "__main__":
+	externs = []
+	lines = open("gl2_api_annotated.in").readlines()
+	i = 0
+	print """// auto generated by generate_MessageFormatter_java.py"
+package GLESv2Debugger;
+
+public class MessageFormatter {
+
+\tstatic String FormatFloats(int count, byte [] data)
+\t{
+\t\tString ret = "[";
+\t\tfor (int i = 0; i < count; i++)
+\t\t{
+\t\t\tint bits = (data[i* 4 + 0] & 0xff) << 24;
+\t\t\tbits |= (data[i* 4 + 1] & 0xff) << 16;
+\t\t\tbits |= (data[i* 4 + 2] & 0xff) << 8;
+\t\t\tbits |= (data[i* 4 + 3] & 0xff) << 0;
+\t\t\tret += Float.intBitsToFloat(bits);
+\t\t\tif (i < count - 1)
+\t\t\t\tret += ", ";
+\t\t}
+\t\treturn ret + "]";
+\t}
+\t
+\tstatic String FormatInts(int count, byte [] data)
+\t{
+\t\tString ret = "[";
+\t\tfor (int i = 0; i < count; i++)
+\t\t{
+\t\t\tint bits = (data[i* 4 + 3] & 0xff) << 24;
+\t\t\tbits |= (data[i* 4 + 2] & 0xff) << 16;
+\t\t\tbits |= (data[i* 4 + 1] & 0xff) << 8;
+\t\t\tbits |= (data[i* 4 + 0] & 0xff) << 0;
+\t\t\tret += bits;
+\t\t\tif (i < count - 1)
+\t\t\t\tret += ", ";
+\t\t}
+\t\treturn ret + "]";
+\t}
+\t
+\tstatic String FormatUints(int count, byte [] data)
+\t{
+\t\tString ret = "[";
+\t\tfor (int i = 0; i < count; i++)
+\t\t{
+\t\t\tlong bits = (data[i* 4 + 3] & 0xff) << 24;
+\t\t\tbits |= (data[i* 4 + 2] & 0xff) << 16;
+\t\t\tbits |= (data[i* 4 + 1] & 0xff) << 8;
+\t\t\tbits |= (data[i* 4 + 0] & 0xff) << 0;
+\t\t\tret += bits;
+\t\t\tif (i < count - 1)
+\t\t\t\tret += ", ";
+\t\t}
+\t\treturn ret + "]";
+\t}
+\t
+\tstatic String FormatMatrix(int columns, int count, byte [] data)
+\t{
+\t\tString ret = "[";
+\t\tfor (int i = 0; i < count; i++)
+\t\t{
+\t\t\tint bits = (data[i* 4 + 0] & 0xff) << 24;
+\t\t\tbits |= (data[i* 4 + 1] & 0xff) << 16;
+\t\t\tbits |= (data[i* 4 + 2] & 0xff) << 8;
+\t\t\tbits |= (data[i* 4 + 3] & 0xff) << 0;
+\t\t\tret += Float.intBitsToFloat(bits);
+\t\t\tif (i % columns == columns - 1)
+\t\t\t\tret += '\\n';
+\t\t\telse if (i < count - 1)
+\t\t\t\tret += ", ";
+\t\t}
+\t\treturn ret + "]";
+\t}
+
+\tpublic static String Format(final DebuggerMessage.Message msg)
+\t{
+\t\tString str;
+\t\tswitch (msg.getFunction())
+\t\t{"""
+        	
+	for line in lines:
+		if line.find("API_ENTRY(") >= 0: # a function prototype
+			returnType = line[0: line.find(" API_ENTRY(")].replace("const ", "")
+			functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name
+			parameterList = line[line.find(")(") + 2: line.find(") {")]
+			#	print "\t\tcase %s:" % (functionName)
+			#	print "\t\t\t//return MessageFormatterCustom.Format(msg);"
+			#	print "\t\t\tstr = msg.toString(); break;"
+			#	#extern = "%s Format_%s(%s);" % (returnType, functionName, parameterList)
+			#	extern = functionName
+			#	externs.append(extern)
+			#	continue
+			
+			parameters = parameterList.split(',')
+			paramIndex = 0
+			
+			formatString = "%s "
+			formatArgs = ""
+			if returnType != "void":
+				if returnType == "GLenum":
+					formatArgs += "GLEnum.valueOf(msg.getRet())"
+				elif returnType.find("*") >= 0:
+					formatArgs += '"0x" + Integer.toHexString(msg.getRet())'
+				else:
+					formatArgs += "msg.getRet()"
+			else:
+				formatArgs += '"void"'
+			
+			#formatString += "%s(" % (functionName)
+			formatString += "("
+			
+			if parameterList == "void":
+				parameters = []
+			
+			paramTypes = []
+			paramNames = []
+			paramAnnotations = []
+			
+			for parameter in parameters:
+				parameter = parameter.replace("const","")
+				parameter = parameter.strip()
+				paramType = parameter.split(' ')[0]
+				paramName = parameter.split(' ')[1]
+				annotation = ""
+				
+				formatString += paramName + "=%s"
+					
+				if parameter.find(":") >= 0:
+					assert paramIndex == len(parameters) - 1 # only last parameter should be annotated
+					inout = paramType.split(":")[2]
+					annotation = paramType.split(":")[1]
+					paramType = paramType.split(":")[0]
+					assert paramType.find("void") < 0
+					count = 1
+					countArg = ""
+					if annotation.find("*") >= 0:
+						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 = annotation
+					else:
+						count = int(annotation)
+					dataFormatter = ""
+					if paramType == "GLfloat":
+						dataFormatter = "FormatFloats"
+					elif paramType == "GLint":
+						dataFormatter = "FormatInts"
+					elif paramType == "GLuint":
+						dataFormatter = "FormatUints"
+					elif annotation == "GLstring":
+						assert paramType == "GLchar"
+					else:
+						assert 0
+					if functionName.find("Matrix") >= 0:
+						columns = int(functionName[functionName.find("fv") - 1: functionName.find("fv")])
+						assert columns * columns == count
+						assert countArg != ""
+						assert paramType == "GLfloat"
+						formatArgs += ", FormatMatrix(%d, %d * msg.getArg%d(), msg.getData().toByteArray())" % (columns, count, paramNames.index(countArg))
+					elif annotation == "GLstring":
+						formatArgs += ", msg.getData().toStringUtf8()"
+					elif countArg == "":
+						formatArgs += ", %s(%d, msg.getData().toByteArray())" % (dataFormatter, count)
+					else:
+						formatArgs += ", %s(%d * msg.getArg%d(), msg.getData().toByteArray())" % (dataFormatter, count, paramNames.index(countArg))
+				else:
+					#formatArgs += ', "%s"' % (paramName)
+					if paramType == "GLfloat" or paramType == "GLclampf":
+						formatArgs += ", Float.intBitsToFloat(msg.getArg%d())" % (paramIndex)
+					elif paramType == "GLenum": 
+						formatArgs += ", GLEnum.valueOf(msg.getArg%d())" % (paramIndex)
+					elif paramType.find("*") >= 0:
+						formatArgs += ', "0x" + Integer.toHexString(msg.getArg%d())' % (paramIndex)
+					else:
+						formatArgs += ", msg.getArg%d()" % (paramIndex)
+				if paramIndex < len(parameters) - 1:
+					formatString += ", "
+	 			paramTypes.append(paramType)
+				paramNames.append(paramName)
+				paramAnnotations.append(annotation)
+				paramIndex += 1  
+
+				
+	 		formatString += ")"
+	 		
+			print "\t\tcase %s:" % (functionName)
+			if line.find("*") >= 0 and (line.find("*") < line.find(":") or line.find("*") > line.rfind(":")):
+				sys.stderr.write(line)
+				print "\t\t\t// FIXME: this function uses pointers, debugger may send data in msg.data"
+			print '\t\t\tstr = String.format("%s", %s); break;' % (formatString, formatArgs)
+			
+
+	print """\t\tdefault:
+\t\t\tstr = msg.toString();
+\t\t}
+\t\treturn str;
+\t}
+}"""
+
+	print """/*
+package GLESv2Debugger;
+
+public class MessageFormatterCustom {
+
+\tpublic static String Format(final DebuggerMessage.Message msg) {
+\t\tString str;
+\t\tswitch (msg.getFunction()) {"""
+
+	for extern in externs:
+		print "\t\tcase %s" % (extern)
+		print "\t\t\t// TODO:"
+
+print """\t\tdefault:
+\t\t\tstr = msg.toString();
+\t\t}
+\t\treturn str;
+\t}
+}
+*/"""	
+		
+		
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..7c0b39e
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_api_cpp.py
@@ -0,0 +1,174 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+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
+	skipFunctions = ["glTexImage2D", "glTexSubImage2D", "glShaderSource"]
+	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(":")):
+				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))
+			
+			if returnType != "void":
+				print "\t%s ret = 0;" % (returnType)
+			print """\tgl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+\tGLESv2Debugger::Message msg, cmd;
+\tmsg.set_context_id(0);
+\tmsg.set_has_next_message(true);
+\tconst bool expectResponse = false;
+\tmsg.set_expect_response(expectResponse);"""
+			print "\tmsg.set_function(GLESv2Debugger::Message_Function_%s);" % (functionName)
+
+			if parameterList == "void":
+				parameters = []
+			
+			arguments = ""
+			 
+			paramTypes = []
+			paramNames = []
+			paramAnnotations = []
+			inout = ""
+			getData = ""
+			
+			for parameter in parameters:
+				parameter = parameter.replace("const", "")
+				parameter = parameter.strip()
+				paramType = parameter.split(' ')[0]
+				paramName = parameter.split(' ')[1]
+				annotation = ""
+				arguments += paramName
+				if parameter.find(":") >= 0:
+					assert paramIndex == len(parameters) - 1 # only last 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]
+					assert paramType.find("void") < 0
+					count = 1
+					countArg = ""
+					if annotation.find("*") >= 0:
+						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)
+			
+					print "\tmsg.set_arg%d(ToInt(%s));" % (paramIndex, paramName)
+					print "\tstd::string data;"
+					getData += "\t\t\tdata.reserve(%s * sizeof(%s));\n" % (annotation, paramType)
+					getData += "\t\t\tfor (unsigned i = 0; i < (%s); i++)\n" % (annotation)
+					getData += "\t\t\t\tdata.append((const char *)(%s + i), sizeof(*%s));\n" % (paramName, paramName)
+					getData += "\t\t\tmsg.set_data(data);"  
+				else:	 
+					if paramIndex < len(parameters) - 1:
+						arguments += ', '
+					if paramType == "GLfloat" or paramType == "GLclampf" or paramType.find("*") >= 0:
+						print "\tmsg.set_arg%d(ToInt(%s));" % (paramIndex, paramName)
+					else: 
+						print "\tmsg.set_arg%d(%s);" % (paramIndex, paramName)
+				paramTypes.append(paramType)
+				paramNames.append(paramName)
+				paramAnnotations.append(annotation)
+				paramIndex += 1
+			if line.find("*") >= 0 or line.find(":") >= 0:
+				print "\t// FIXME: check for pointer usage"
+			if inout in ["in", "inout"]:
+				print getData
+	 		print """\tSend(msg, cmd);
+\tif (!expectResponse)
+\t\tcmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+\twhile (true) {
+\t\tmsg.Clear();
+\t\tclock_t c0 = clock();
+\t\tswitch (cmd.function()) {
+\t\tcase GLESv2Debugger::Message_Function_CONTINUE:"""
+			if returnType == "void":
+				print "\t\t\t_c->%s(%s);" % (functionName, arguments)
+			
+			else:
+				print "\t\t\tret = _c->%s(%s);" % (functionName, arguments)
+				if returnType == "GLboolean":
+					print "\t\t\tmsg.set_ret(ret);"
+				else:
+					print "\t\t\tmsg.set_ret(ToInt(ret));"
+			print "\t\t\tmsg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);"
+			print "\t\t\tmsg.set_context_id(0);"
+			print "\t\t\tmsg.set_function(GLESv2Debugger::Message_Function_%s);" % (functionName)
+			print """\t\t\tmsg.set_has_next_message(false);
+\t\t\tmsg.set_expect_response(expectResponse);"""
+			if inout in ["out", "inout"]:
+				print getData
+			print """\t\t\tSend(msg, cmd);
+\t\t\tif (!expectResponse)
+\t\t\t\tcmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+\t\t\tbreak;
+\t\tcase GLESv2Debugger::Message_Function_SKIP:"""
+			if returnType == "void":
+				print "\t\t\treturn;"
+			else:
+				print "\t\t\tif (cmd.has_ret())"
+				if returnType == "GLboolean":
+					print "\t\t\t\tret = cmd.ret();"
+				else:
+					print "\t\t\t\tret = FromInt<%s>(cmd.ret());" % (returnType)
+				print "\t\t\treturn ret;"
+			print """\t\tdefault:
+\t\t\tASSERT(0); //GenerateCall(msg, cmd); 
+\t\t\tbreak;
+\t\t}
+\t}
+}
+"""
+			#break
+
+	print "// FIXME: the following functions should be written by hand"
+	for extern in externs:
+		print extern
+
+if __name__ == "__main__":
+	print "// auto generated by generate_api_cpp.py\n"
+	print '''#include  "src/header.h"\n'''
+	print "template<typename T> static int ToInt(const T & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (int &)t; }\n"
+	print "template<typename T> static T FromInt(const int & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (T &)t; }\n"
+	
+	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..830bcb9
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/generate_debug_in.py
@@ -0,0 +1,64 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+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.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/gl2_api_annotated.in b/opengl/libs/GLES2_dbg/gl2_api_annotated.in
new file mode 100644
index 0000000..2296570
--- /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* data, GLenum usage) {
+    CALL_GL_API(glBufferData, target, size, data, usage);
+}
+void API_ENTRY(glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* 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/include/glesv2_dbg.h b/opengl/libs/GLES2_dbg/include/glesv2_dbg.h
new file mode 100644
index 0000000..2d70032
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/include/glesv2_dbg.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)
+
+
+}
diff --git a/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.cpp b/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.cpp
new file mode 100644
index 0000000..d9c8816
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.cpp
@@ -0,0 +1,1038 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "DebuggerMessage.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 GLESv2Debugger {
+
+void protobuf_ShutdownFile_DebuggerMessage_2eproto() {
+  delete Message::default_instance_;
+}
+
+void protobuf_AddDesc_DebuggerMessage_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_DebuggerMessage_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_DebuggerMessage_2eproto {
+  StaticDescriptorInitializer_DebuggerMessage_2eproto() {
+    protobuf_AddDesc_DebuggerMessage_2eproto();
+  }
+} static_descriptor_initializer_DebuggerMessage_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:
+      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::ACK;
+const Message_Function Message::NEG;
+const Message_Function Message::CONTINUE;
+const Message_Function Message::SKIP;
+const Message_Function Message::Function_MIN;
+const Message_Function Message::Function_MAX;
+const int Message::Function_ARRAYSIZE;
+#endif  // _MSC_VER
+const ::std::string Message::_default_data_;
+#ifndef _MSC_VER
+const int Message::kContextIdFieldNumber;
+const int Message::kFunctionFieldNumber;
+const int Message::kHasNextMessageFieldNumber;
+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;
+#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_ = 143;
+  has_next_message_ = false;
+  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;
+  ::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_DebuggerMessage_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_ = 143;
+    has_next_message_ = false;
+    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;
+  }
+  ::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 .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 (::GLESv2Debugger::Message_Function_IsValid(value)) {
+            set_function(static_cast< ::GLESv2Debugger::Message_Function >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(24)) goto parse_has_next_message;
+        break;
+      }
+      
+      // required bool has_next_message = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_has_next_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &has_next_message_)));
+          _set_bit(2);
+        } 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->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 .GLESv2Debugger.Message.Function function = 2 [default = NEG];
+  if (_has_bit(1)) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->function(), output);
+  }
+  
+  // required bool has_next_message = 3;
+  if (_has_bit(2)) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->has_next_message(), 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);
+  }
+  
+}
+
+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 .GLESv2Debugger.Message.Function function = 2 [default = NEG];
+    if (has_function()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->function());
+    }
+    
+    // required bool has_next_message = 3;
+    if (has_has_next_message()) {
+      total_size += 1 + 1;
+    }
+    
+    // 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;
+    }
+    
+  }
+  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_has_next_message(from.has_next_message());
+    }
+    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());
+    }
+  }
+}
+
+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(has_next_message_, other->has_next_message_);
+    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(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string Message::GetTypeName() const {
+  return "GLESv2Debugger.Message";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace GLESv2Debugger
+
+// @@protoc_insertion_point(global_scope)
diff --git a/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.h b/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.h
new file mode 100644
index 0000000..e9b4142
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/DebuggerMessage.pb.h
@@ -0,0 +1,844 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: DebuggerMessage.proto
+
+#ifndef PROTOBUF_DebuggerMessage_2eproto__INCLUDED
+#define PROTOBUF_DebuggerMessage_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 GLESv2Debugger {
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_DebuggerMessage_2eproto();
+void protobuf_AssignDesc_DebuggerMessage_2eproto();
+void protobuf_ShutdownFile_DebuggerMessage_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_ACK = 142,
+  Message_Function_NEG = 143,
+  Message_Function_CONTINUE = 144,
+  Message_Function_SKIP = 145
+};
+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_SKIP;
+const int Message_Function_Function_ARRAYSIZE = Message_Function_Function_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 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 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;
+  
+  // 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 .GLESv2Debugger.Message.Function function = 2 [default = NEG];
+  inline bool has_function() const;
+  inline void clear_function();
+  static const int kFunctionFieldNumber = 2;
+  inline ::GLESv2Debugger::Message_Function function() const;
+  inline void set_function(::GLESv2Debugger::Message_Function value);
+  
+  // required bool has_next_message = 3;
+  inline bool has_has_next_message() const;
+  inline void clear_has_next_message();
+  static const int kHasNextMessageFieldNumber = 3;
+  inline bool has_next_message() const;
+  inline void set_has_next_message(bool 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);
+  
+  // @@protoc_insertion_point(class_scope:GLESv2Debugger.Message)
+ private:
+  mutable int _cached_size_;
+  
+  ::google::protobuf::int32 context_id_;
+  int function_;
+  bool has_next_message_;
+  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_;
+  friend void  protobuf_AddDesc_DebuggerMessage_2eproto();
+  friend void protobuf_AssignDesc_DebuggerMessage_2eproto();
+  friend void protobuf_ShutdownFile_DebuggerMessage_2eproto();
+  
+  ::google::protobuf::uint32 _has_bits_[(16 + 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 .GLESv2Debugger.Message.Function function = 2 [default = NEG];
+inline bool Message::has_function() const {
+  return _has_bit(1);
+}
+inline void Message::clear_function() {
+  function_ = 143;
+  _clear_bit(1);
+}
+inline ::GLESv2Debugger::Message_Function Message::function() const {
+  return static_cast< ::GLESv2Debugger::Message_Function >(function_);
+}
+inline void Message::set_function(::GLESv2Debugger::Message_Function value) {
+  GOOGLE_DCHECK(::GLESv2Debugger::Message_Function_IsValid(value));
+  _set_bit(1);
+  function_ = value;
+}
+
+// required bool has_next_message = 3;
+inline bool Message::has_has_next_message() const {
+  return _has_bit(2);
+}
+inline void Message::clear_has_next_message() {
+  has_next_message_ = false;
+  _clear_bit(2);
+}
+inline bool Message::has_next_message() const {
+  return has_next_message_;
+}
+inline void Message::set_has_next_message(bool value) {
+  _set_bit(2);
+  has_next_message_ = 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;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace GLESv2Debugger
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_DebuggerMessage_2eproto__INCLUDED
diff --git a/opengl/libs/GLES2_dbg/src/api.cpp b/opengl/libs/GLES2_dbg/src/api.cpp
new file mode 100644
index 0000000..b2b8ec0
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/api.cpp
@@ -0,0 +1,5730 @@
+// auto generated by generate_api_cpp.py
+
+#include  "src/header.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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glActiveTexture);
+	msg.set_arg0(texture);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glActiveTexture(texture);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glActiveTexture);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glAttachShader(GLuint program, GLuint shader)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glAttachShader);
+	msg.set_arg0(program);
+	msg.set_arg1(shader);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glAttachShader(program, shader);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glAttachShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBindAttribLocation);
+	msg.set_arg0(program);
+	msg.set_arg1(index);
+	msg.set_arg2(ToInt(name));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(strlen(name) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(name)); i++)
+				data.append((const char *)(name + i), sizeof(*name));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBindAttribLocation(program, index, name);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBindAttribLocation);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBindBuffer(GLenum target, GLuint buffer)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBindBuffer);
+	msg.set_arg0(target);
+	msg.set_arg1(buffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBindBuffer(target, buffer);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBindBuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBindFramebuffer);
+	msg.set_arg0(target);
+	msg.set_arg1(framebuffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBindFramebuffer(target, framebuffer);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBindFramebuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBindRenderbuffer);
+	msg.set_arg0(target);
+	msg.set_arg1(renderbuffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBindRenderbuffer(target, renderbuffer);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBindRenderbuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBindTexture(GLenum target, GLuint texture)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBindTexture);
+	msg.set_arg0(target);
+	msg.set_arg1(texture);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBindTexture(target, texture);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBindTexture);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBlendColor);
+	msg.set_arg0(ToInt(red));
+	msg.set_arg1(ToInt(green));
+	msg.set_arg2(ToInt(blue));
+	msg.set_arg3(ToInt(alpha));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBlendColor(red, green, blue, alpha);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBlendColor);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBlendEquation( GLenum mode )
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBlendEquation);
+	msg.set_arg0(mode);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBlendEquation(mode);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBlendEquation);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBlendEquationSeparate);
+	msg.set_arg0(modeRGB);
+	msg.set_arg1(modeAlpha);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBlendEquationSeparate(modeRGB, modeAlpha);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBlendEquationSeparate);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBlendFunc);
+	msg.set_arg0(sfactor);
+	msg.set_arg1(dfactor);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBlendFunc(sfactor, dfactor);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBlendFunc);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBlendFuncSeparate);
+	msg.set_arg0(srcRGB);
+	msg.set_arg1(dstRGB);
+	msg.set_arg2(srcAlpha);
+	msg.set_arg3(dstAlpha);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBlendFuncSeparate);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBufferData);
+	msg.set_arg0(target);
+	msg.set_arg1(size);
+	msg.set_arg2(ToInt(data));
+	msg.set_arg3(usage);
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBufferData(target, size, data, usage);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBufferData);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glBufferSubData);
+	msg.set_arg0(target);
+	msg.set_arg1(offset);
+	msg.set_arg2(size);
+	msg.set_arg3(ToInt(data));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glBufferSubData(target, offset, size, data);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glBufferSubData);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+GLenum Debug_glCheckFramebufferStatus(GLenum target)
+{
+	GLenum ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCheckFramebufferStatus);
+	msg.set_arg0(target);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glCheckFramebufferStatus(target);
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCheckFramebufferStatus);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<GLenum>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+void Debug_glClear(GLbitfield mask)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glClear);
+	msg.set_arg0(mask);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glClear(mask);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glClear);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glClearColor);
+	msg.set_arg0(ToInt(red));
+	msg.set_arg1(ToInt(green));
+	msg.set_arg2(ToInt(blue));
+	msg.set_arg3(ToInt(alpha));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glClearColor(red, green, blue, alpha);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glClearColor);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glClearDepthf(GLclampf depth)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glClearDepthf);
+	msg.set_arg0(ToInt(depth));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glClearDepthf(depth);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glClearDepthf);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glClearStencil(GLint s)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glClearStencil);
+	msg.set_arg0(s);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glClearStencil(s);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glClearStencil);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glColorMask);
+	msg.set_arg0(red);
+	msg.set_arg1(green);
+	msg.set_arg2(blue);
+	msg.set_arg3(alpha);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glColorMask(red, green, blue, alpha);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glColorMask);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glCompileShader(GLuint shader)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCompileShader);
+	msg.set_arg0(shader);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCompileShader(shader);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCompileShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCompressedTexImage2D);
+	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
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCompressedTexImage2D);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCompressedTexSubImage2D);
+	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
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCompressedTexSubImage2D);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCopyTexImage2D);
+	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);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCopyTexImage2D);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCopyTexSubImage2D);
+	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);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCopyTexSubImage2D);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+GLuint Debug_glCreateProgram(void)
+{
+	GLuint ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCreateProgram);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glCreateProgram();
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCreateProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<GLuint>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLuint Debug_glCreateShader(GLenum type)
+{
+	GLuint ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCreateShader);
+	msg.set_arg0(type);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glCreateShader(type);
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCreateShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<GLuint>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+void Debug_glCullFace(GLenum mode)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glCullFace);
+	msg.set_arg0(mode);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glCullFace(mode);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glCullFace);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteBuffers(GLsizei n, const GLuint* buffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteBuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(buffers));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(buffers + i), sizeof(*buffers));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteBuffers(n, buffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteBuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteFramebuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(framebuffers));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(framebuffers + i), sizeof(*framebuffers));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteFramebuffers(n, framebuffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteFramebuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteProgram(GLuint program)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteProgram);
+	msg.set_arg0(program);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteProgram(program);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteRenderbuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(renderbuffers));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(renderbuffers + i), sizeof(*renderbuffers));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteRenderbuffers(n, renderbuffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteRenderbuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteShader(GLuint shader)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteShader);
+	msg.set_arg0(shader);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteShader(shader);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDeleteTextures(GLsizei n, const GLuint* textures)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDeleteTextures);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(textures));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(textures + i), sizeof(*textures));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDeleteTextures(n, textures);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDeleteTextures);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDepthFunc(GLenum func)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDepthFunc);
+	msg.set_arg0(func);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDepthFunc(func);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDepthFunc);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDepthMask(GLboolean flag)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDepthMask);
+	msg.set_arg0(flag);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDepthMask(flag);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDepthMask);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDepthRangef(GLclampf zNear, GLclampf zFar)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDepthRangef);
+	msg.set_arg0(ToInt(zNear));
+	msg.set_arg1(ToInt(zFar));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDepthRangef(zNear, zFar);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDepthRangef);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDetachShader(GLuint program, GLuint shader)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDetachShader);
+	msg.set_arg0(program);
+	msg.set_arg1(shader);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDetachShader(program, shader);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDetachShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDisable(GLenum cap)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDisable);
+	msg.set_arg0(cap);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDisable(cap);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDisable);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glDisableVertexAttribArray(GLuint index)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glDisableVertexAttribArray);
+	msg.set_arg0(index);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDisableVertexAttribArray(index);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDisableVertexAttribArray);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	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);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDrawArrays(mode, first, count);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDrawArrays);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	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(ToInt(indices));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glDrawElements(mode, count, type, indices);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glDrawElements);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glEnable(GLenum cap)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glEnable);
+	msg.set_arg0(cap);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glEnable(cap);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glEnable);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glEnableVertexAttribArray(GLuint index)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glEnableVertexAttribArray);
+	msg.set_arg0(index);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glEnableVertexAttribArray(index);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glEnableVertexAttribArray);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glFinish(void)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glFinish);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glFinish();
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glFinish);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glFlush(void)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glFlush);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glFlush();
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glFlush);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glFramebufferRenderbuffer);
+	msg.set_arg0(target);
+	msg.set_arg1(attachment);
+	msg.set_arg2(renderbuffertarget);
+	msg.set_arg3(renderbuffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glFramebufferRenderbuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glFramebufferTexture2D);
+	msg.set_arg0(target);
+	msg.set_arg1(attachment);
+	msg.set_arg2(textarget);
+	msg.set_arg3(texture);
+	msg.set_arg4(level);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glFramebufferTexture2D(target, attachment, textarget, texture, level);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glFramebufferTexture2D);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glFrontFace(GLenum mode)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glFrontFace);
+	msg.set_arg0(mode);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glFrontFace(mode);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glFrontFace);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glGenBuffers(GLsizei n, GLuint* buffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGenBuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(buffers));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGenBuffers(n, buffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGenBuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(buffers + i), sizeof(*buffers));
+			msg.set_data(data);
+			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_glGenerateMipmap(GLenum target)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGenerateMipmap);
+	msg.set_arg0(target);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGenerateMipmap(target);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGenerateMipmap);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGenFramebuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(framebuffers));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGenFramebuffers(n, framebuffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGenFramebuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(framebuffers + i), sizeof(*framebuffers));
+			msg.set_data(data);
+			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_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGenRenderbuffers);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(renderbuffers));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGenRenderbuffers(n, renderbuffers);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGenRenderbuffers);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(renderbuffers + i), sizeof(*renderbuffers));
+			msg.set_data(data);
+			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_glGenTextures(GLsizei n, GLuint* textures)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGenTextures);
+	msg.set_arg0(n);
+	msg.set_arg1(ToInt(textures));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGenTextures(n, textures);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGenTextures);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(n * sizeof(GLuint));
+			for (unsigned i = 0; i < (n); i++)
+				data.append((const char *)(textures + i), sizeof(*textures));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetActiveAttrib);
+	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));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(strlen(name) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(name)); i++)
+				data.append((const char *)(name + i), sizeof(*name));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetActiveAttrib(program, index, bufsize, length, size, type, name);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetActiveAttrib);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetActiveUniform);
+	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));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(strlen(name) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(name)); i++)
+				data.append((const char *)(name + i), sizeof(*name));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetActiveUniform(program, index, bufsize, length, size, type, name);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetActiveUniform);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetAttachedShaders);
+	msg.set_arg0(program);
+	msg.set_arg1(maxcount);
+	msg.set_arg2(ToInt(count));
+	msg.set_arg3(ToInt(shaders));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetAttachedShaders(program, maxcount, count, shaders);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetAttachedShaders);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+int Debug_glGetAttribLocation(GLuint program, const GLchar* name)
+{
+	int ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetAttribLocation);
+	msg.set_arg0(program);
+	msg.set_arg1(ToInt(name));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(strlen(name) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(name)); i++)
+				data.append((const char *)(name + i), sizeof(*name));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glGetAttribLocation(program, name);
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetAttribLocation);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<int>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetBooleanv(GLenum pname, GLboolean* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetBooleanv);
+	msg.set_arg0(pname);
+	msg.set_arg1(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetBooleanv(pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetBooleanv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetBufferParameteriv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetBufferParameteriv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetBufferParameteriv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+GLenum Debug_glGetError(void)
+{
+	GLenum ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetError);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glGetError();
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetError);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<GLenum>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetFloatv(GLenum pname, GLfloat* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetFloatv);
+	msg.set_arg0(pname);
+	msg.set_arg1(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetFloatv(pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetFloatv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetFramebufferAttachmentParameteriv);
+	msg.set_arg0(target);
+	msg.set_arg1(attachment);
+	msg.set_arg2(pname);
+	msg.set_arg3(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetFramebufferAttachmentParameteriv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetIntegerv(GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetIntegerv);
+	msg.set_arg0(pname);
+	msg.set_arg1(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetIntegerv(pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetIntegerv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetProgramiv);
+	msg.set_arg0(program);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetProgramiv(program, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetProgramiv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(1 * sizeof(GLint));
+			for (unsigned i = 0; i < (1); i++)
+				data.append((const char *)(params + i), sizeof(*params));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetProgramInfoLog);
+	msg.set_arg0(program);
+	msg.set_arg1(bufsize);
+	msg.set_arg2(ToInt(length));
+	msg.set_arg3(ToInt(infolog));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetProgramInfoLog(program, bufsize, length, infolog);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetProgramInfoLog);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(strlen(infolog) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(infolog)); i++)
+				data.append((const char *)(infolog + i), sizeof(*infolog));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetRenderbufferParameteriv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetRenderbufferParameteriv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetRenderbufferParameteriv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetShaderiv);
+	msg.set_arg0(shader);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetShaderiv(shader, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetShaderiv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(1 * sizeof(GLint));
+			for (unsigned i = 0; i < (1); i++)
+				data.append((const char *)(params + i), sizeof(*params));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetShaderInfoLog);
+	msg.set_arg0(shader);
+	msg.set_arg1(bufsize);
+	msg.set_arg2(ToInt(length));
+	msg.set_arg3(ToInt(infolog));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetShaderInfoLog(shader, bufsize, length, infolog);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetShaderInfoLog);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(strlen(infolog) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(infolog)); i++)
+				data.append((const char *)(infolog + i), sizeof(*infolog));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetShaderPrecisionFormat);
+	msg.set_arg0(shadertype);
+	msg.set_arg1(precisiontype);
+	msg.set_arg2(ToInt(range));
+	msg.set_arg3(ToInt(precision));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetShaderPrecisionFormat);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetShaderSource);
+	msg.set_arg0(shader);
+	msg.set_arg1(bufsize);
+	msg.set_arg2(ToInt(length));
+	msg.set_arg3(ToInt(source));
+	std::string data;
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetShaderSource(shader, bufsize, length, source);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetShaderSource);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			data.reserve(strlen(source) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(source)); i++)
+				data.append((const char *)(source + i), sizeof(*source));
+			msg.set_data(data);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+const GLubyte* Debug_glGetString(GLenum name)
+{
+	const GLubyte* ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetString);
+	msg.set_arg0(name);
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glGetString(name);
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetString);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<const GLubyte*>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetTexParameterfv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetTexParameterfv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetTexParameterfv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetTexParameteriv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetTexParameteriv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetTexParameteriv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetUniformfv);
+	msg.set_arg0(program);
+	msg.set_arg1(location);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetUniformfv(program, location, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetUniformfv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetUniformiv(GLuint program, GLint location, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetUniformiv);
+	msg.set_arg0(program);
+	msg.set_arg1(location);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetUniformiv(program, location, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetUniformiv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+int Debug_glGetUniformLocation(GLuint program, const GLchar* name)
+{
+	int ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetUniformLocation);
+	msg.set_arg0(program);
+	msg.set_arg1(ToInt(name));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(strlen(name) * sizeof(GLchar));
+			for (unsigned i = 0; i < (strlen(name)); i++)
+				data.append((const char *)(name + i), sizeof(*name));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glGetUniformLocation(program, name);
+			msg.set_ret(ToInt(ret));
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetUniformLocation);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = FromInt<int>(cmd.ret());
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribfv);
+	msg.set_arg0(index);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetVertexAttribfv(index, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribfv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribiv);
+	msg.set_arg0(index);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetVertexAttribiv(index, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribiv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribPointerv);
+	msg.set_arg0(index);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(pointer));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glGetVertexAttribPointerv(index, pname, pointer);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glGetVertexAttribPointerv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glHint(GLenum target, GLenum mode)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glHint);
+	msg.set_arg0(target);
+	msg.set_arg1(mode);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glHint(target, mode);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glHint);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+GLboolean Debug_glIsBuffer(GLuint buffer)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsBuffer);
+	msg.set_arg0(buffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsBuffer(buffer);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsBuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsEnabled(GLenum cap)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsEnabled);
+	msg.set_arg0(cap);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsEnabled(cap);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsEnabled);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsFramebuffer(GLuint framebuffer)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsFramebuffer);
+	msg.set_arg0(framebuffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsFramebuffer(framebuffer);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsFramebuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsProgram(GLuint program)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsProgram);
+	msg.set_arg0(program);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsProgram(program);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsRenderbuffer(GLuint renderbuffer)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsRenderbuffer);
+	msg.set_arg0(renderbuffer);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsRenderbuffer(renderbuffer);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsRenderbuffer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsShader(GLuint shader)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsShader);
+	msg.set_arg0(shader);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsShader(shader);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsShader);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+GLboolean Debug_glIsTexture(GLuint texture)
+{
+	GLboolean ret = 0;
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glIsTexture);
+	msg.set_arg0(texture);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			ret = _c->glIsTexture(texture);
+			msg.set_ret(ret);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glIsTexture);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			Send(msg, cmd);
+			if (!expectResponse)
+				cmd.set_function(GLESv2Debugger::Message_Function_SKIP);
+			break;
+		case GLESv2Debugger::Message_Function_SKIP:
+			if (cmd.has_ret())
+				ret = cmd.ret();
+			return ret;
+		default:
+			ASSERT(0); //GenerateCall(msg, cmd); 
+			break;
+		}
+	}
+}
+
+void Debug_glLineWidth(GLfloat width)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glLineWidth);
+	msg.set_arg0(ToInt(width));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glLineWidth(width);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glLineWidth);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glLinkProgram(GLuint program)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glLinkProgram);
+	msg.set_arg0(program);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glLinkProgram(program);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glLinkProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glPixelStorei(GLenum pname, GLint param)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glPixelStorei);
+	msg.set_arg0(pname);
+	msg.set_arg1(param);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glPixelStorei(pname, param);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glPixelStorei);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glPolygonOffset(GLfloat factor, GLfloat units)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glPolygonOffset);
+	msg.set_arg0(ToInt(factor));
+	msg.set_arg1(ToInt(units));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glPolygonOffset(factor, units);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glPolygonOffset);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	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(ToInt(pixels));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glReadPixels(x, y, width, height, format, type, pixels);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glReadPixels);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glReleaseShaderCompiler(void)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glReleaseShaderCompiler);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glReleaseShaderCompiler();
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glReleaseShaderCompiler);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glRenderbufferStorage);
+	msg.set_arg0(target);
+	msg.set_arg1(internalformat);
+	msg.set_arg2(width);
+	msg.set_arg3(height);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glRenderbufferStorage(target, internalformat, width, height);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glRenderbufferStorage);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glSampleCoverage(GLclampf value, GLboolean invert)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glSampleCoverage);
+	msg.set_arg0(ToInt(value));
+	msg.set_arg1(invert);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glSampleCoverage(value, invert);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glSampleCoverage);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glScissor);
+	msg.set_arg0(x);
+	msg.set_arg1(y);
+	msg.set_arg2(width);
+	msg.set_arg3(height);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glScissor(x, y, width, height);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glScissor);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glShaderBinary);
+	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
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glShaderBinary(n, shaders, binaryformat, binary, length);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glShaderBinary);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilFunc);
+	msg.set_arg0(func);
+	msg.set_arg1(ref);
+	msg.set_arg2(mask);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilFunc(func, ref, mask);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilFunc);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilFuncSeparate);
+	msg.set_arg0(face);
+	msg.set_arg1(func);
+	msg.set_arg2(ref);
+	msg.set_arg3(mask);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilFuncSeparate(face, func, ref, mask);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilFuncSeparate);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilMask(GLuint mask)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilMask);
+	msg.set_arg0(mask);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilMask(mask);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilMask);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilMaskSeparate(GLenum face, GLuint mask)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilMaskSeparate);
+	msg.set_arg0(face);
+	msg.set_arg1(mask);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilMaskSeparate(face, mask);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilMaskSeparate);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilOp);
+	msg.set_arg0(fail);
+	msg.set_arg1(zfail);
+	msg.set_arg2(zpass);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilOp(fail, zfail, zpass);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilOp);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glStencilOpSeparate);
+	msg.set_arg0(face);
+	msg.set_arg1(fail);
+	msg.set_arg2(zfail);
+	msg.set_arg3(zpass);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glStencilOpSeparate(face, fail, zfail, zpass);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glStencilOpSeparate);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glTexParameterf);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(param));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glTexParameterf(target, pname, param);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glTexParameterf);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glTexParameterfv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glTexParameterfv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glTexParameterfv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glTexParameteri);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(param);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glTexParameteri(target, pname, param);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glTexParameteri);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: this function has pointers, it should be hand written
+void Debug_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glTexParameteriv);
+	msg.set_arg0(target);
+	msg.set_arg1(pname);
+	msg.set_arg2(ToInt(params));
+	// FIXME: check for pointer usage
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glTexParameteriv(target, pname, params);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glTexParameteriv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform1f(GLint location, GLfloat x)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform1f);
+	msg.set_arg0(location);
+	msg.set_arg1(ToInt(x));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform1f(location, x);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform1f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform1fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(1*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (1*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform1fv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform1fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform1i(GLint location, GLint x)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform1i);
+	msg.set_arg0(location);
+	msg.set_arg1(x);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform1i(location, x);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform1i);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform1iv(GLint location, GLsizei count, const GLint* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform1iv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(1*count * sizeof(GLint));
+			for (unsigned i = 0; i < (1*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform1iv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform1iv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform2f(GLint location, GLfloat x, GLfloat y)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform2f);
+	msg.set_arg0(location);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform2f(location, x, y);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform2f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform2fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(2*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (2*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform2fv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform2fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform2i(GLint location, GLint x, GLint y)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform2i);
+	msg.set_arg0(location);
+	msg.set_arg1(x);
+	msg.set_arg2(y);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform2i(location, x, y);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform2i);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform2iv(GLint location, GLsizei count, const GLint* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform2iv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(2*count * sizeof(GLint));
+			for (unsigned i = 0; i < (2*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform2iv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform2iv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform3f);
+	msg.set_arg0(location);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	msg.set_arg3(ToInt(z));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform3f(location, x, y, z);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform3f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform3fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(3*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (3*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform3fv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform3fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform3i(GLint location, GLint x, GLint y, GLint z)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform3i);
+	msg.set_arg0(location);
+	msg.set_arg1(x);
+	msg.set_arg2(y);
+	msg.set_arg3(z);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform3i(location, x, y, z);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform3i);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform3iv(GLint location, GLsizei count, const GLint* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform3iv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(3*count * sizeof(GLint));
+			for (unsigned i = 0; i < (3*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform3iv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform3iv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform4f);
+	msg.set_arg0(location);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	msg.set_arg3(ToInt(z));
+	msg.set_arg4(ToInt(w));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform4f(location, x, y, z, w);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform4f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform4fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(4*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (4*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform4fv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform4fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform4i);
+	msg.set_arg0(location);
+	msg.set_arg1(x);
+	msg.set_arg2(y);
+	msg.set_arg3(z);
+	msg.set_arg4(w);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform4i(location, x, y, z, w);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform4i);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniform4iv(GLint location, GLsizei count, const GLint* v)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniform4iv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(ToInt(v));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(4*count * sizeof(GLint));
+			for (unsigned i = 0; i < (4*count); i++)
+				data.append((const char *)(v + i), sizeof(*v));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniform4iv(location, count, v);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniform4iv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix2fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(transpose);
+	msg.set_arg3(ToInt(value));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(4*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (4*count); i++)
+				data.append((const char *)(value + i), sizeof(*value));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniformMatrix2fv(location, count, transpose, value);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix2fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix3fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(transpose);
+	msg.set_arg3(ToInt(value));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(9*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (9*count); i++)
+				data.append((const char *)(value + i), sizeof(*value));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniformMatrix3fv(location, count, transpose, value);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix3fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix4fv);
+	msg.set_arg0(location);
+	msg.set_arg1(count);
+	msg.set_arg2(transpose);
+	msg.set_arg3(ToInt(value));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(16*count * sizeof(GLfloat));
+			for (unsigned i = 0; i < (16*count); i++)
+				data.append((const char *)(value + i), sizeof(*value));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUniformMatrix4fv(location, count, transpose, value);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUniformMatrix4fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glUseProgram(GLuint program)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glUseProgram);
+	msg.set_arg0(program);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glUseProgram(program);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glUseProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glValidateProgram(GLuint program)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glValidateProgram);
+	msg.set_arg0(program);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glValidateProgram(program);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glValidateProgram);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib1f(GLuint indx, GLfloat x)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib1f);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(x));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib1f(indx, x);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib1f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib1fv);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(values));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(1 * sizeof(GLfloat));
+			for (unsigned i = 0; i < (1); i++)
+				data.append((const char *)(values + i), sizeof(*values));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib1fv(indx, values);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib1fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib2f);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib2f(indx, x, y);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib2f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib2fv);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(values));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(2 * sizeof(GLfloat));
+			for (unsigned i = 0; i < (2); i++)
+				data.append((const char *)(values + i), sizeof(*values));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib2fv(indx, values);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib2fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib3f);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	msg.set_arg3(ToInt(z));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib3f(indx, x, y, z);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib3f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib3fv);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(values));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(3 * sizeof(GLfloat));
+			for (unsigned i = 0; i < (3); i++)
+				data.append((const char *)(values + i), sizeof(*values));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib3fv(indx, values);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib3fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib4f);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(x));
+	msg.set_arg2(ToInt(y));
+	msg.set_arg3(ToInt(z));
+	msg.set_arg4(ToInt(w));
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib4f(indx, x, y, z, w);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib4f);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib4fv);
+	msg.set_arg0(indx);
+	msg.set_arg1(ToInt(values));
+	std::string data;
+	// FIXME: check for pointer usage
+			data.reserve(4 * sizeof(GLfloat));
+			for (unsigned i = 0; i < (4); i++)
+				data.append((const char *)(values + i), sizeof(*values));
+			msg.set_data(data);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttrib4fv(indx, values);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttrib4fv);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// 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)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glVertexAttribPointer);
+	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
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glVertexAttribPointer);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+	GLESv2Debugger::Message msg, cmd;
+	msg.set_context_id(0);
+	msg.set_has_next_message(true);
+	const bool expectResponse = false;
+	msg.set_expect_response(expectResponse);
+	msg.set_function(GLESv2Debugger::Message_Function_glViewport);
+	msg.set_arg0(x);
+	msg.set_arg1(y);
+	msg.set_arg2(width);
+	msg.set_arg3(height);
+	Send(msg, cmd);
+	if (!expectResponse)
+		cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+	while (true) {
+		msg.Clear();
+		clock_t c0 = clock();
+		switch (cmd.function()) {
+		case GLESv2Debugger::Message_Function_CONTINUE:
+			_c->glViewport(x, y, width, height);
+			msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+			msg.set_context_id(0);
+			msg.set_function(GLESv2Debugger::Message_Function_glViewport);
+			msg.set_has_next_message(false);
+			msg.set_expect_response(expectResponse);
+			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;
+		}
+	}
+}
+
+// FIXME: the following functions should be written by hand
+void Debug_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
+void Debug_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
+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_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
+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_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
+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/header.h b/opengl/libs/GLES2_dbg/src/header.h
new file mode 100644
index 0000000..e1b194d
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/header.h
@@ -0,0 +1,65 @@
+/*
+ ** 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 <sys/ioctl.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <cutils/log.h>
+#include <cutils/properties.h>
+#include <../../../libcore/include/StaticAssert.h>
+
+#define EGL_TRACE 1
+#include "hooks.h"
+
+#define GL_ENTRY(_r, _api, ...) _r Debug_##_api ( __VA_ARGS__ );
+#include "../include/glesv2_dbg.h"
+
+#include "DebuggerMessage.pb.h"
+
+using namespace 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
+
+#define ASSERT(expr) if (!(expr)) { LOGD("\n*\n*\n* ASSERT FAILED: %s at %s \n*\n*", #expr, __location__); exit(1); }
+#undef assert
+#define assert(expr) ASSERT(expr)
+//#undef LOGD
+//#define LOGD(...)
+
+namespace android
+{
+extern int clientSock, serverSock;
+#define BUFFSIZE 256
+extern char sockBuff [BUFFSIZE];
+
+void Send(const GLESv2Debugger::Message & msg, 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..33f78e4
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/server.cpp
@@ -0,0 +1,158 @@
+/*
+ ** 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 <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <pthread.h>
+
+#include "header.h"
+
+namespace android
+{
+
+char sockBuff [BUFFSIZE];
+
+int serverSock = -1, clientSock = -1;
+
+void StopDebugServer();
+
+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_has_next_message(false);
+    msg.set_expect_response(true);
+    Send(msg, cmd);
+}
+
+void StopDebugServer()
+{
+    LOGD("GLESv2_dbg: StopDebugServer");
+    if (clientSock > 0) {
+        close(clientSock);
+        clientSock = -1;
+    }
+    if (serverSock > 0) {
+        close(serverSock);
+        serverSock = -1;
+    }
+
+}
+
+void 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
+
+    static std::string str;
+    const_cast<GLESv2Debugger::Message &>(msg).set_context_id(pthread_self());
+    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");
+    }
+    sent = send(clientSock, str.c_str(), str.length(), 0);
+    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;
+    }
+
+    int received = recv(clientSock, sockBuff, 4, MSG_WAITALL);
+    if (received < 0)
+        Die("Failed to receive response");
+    else if (4 != received) {
+        LOGD("received %dB: %.8X", received, *(unsigned *)sockBuff);
+        Die("Received length mismatch, expected 4");
+    }
+    len = ntohl(*(unsigned *)sockBuff);
+    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);
+
+    //LOGD("Message sent tid=%lu len=%d", pthread_self(), str.length());
+    pthread_mutex_unlock(&mutex);
+}
+
+}; // namespace android {
diff --git a/opengl/libs/GLES2_dbg/src/shader.cpp b/opengl/libs/GLES2_dbg/src/shader.cpp
new file mode 100644
index 0000000..c2b2557
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/shader.cpp
@@ -0,0 +1,66 @@
+/*
+ ** 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"
+
+void API_ENTRY(glShaderSource)(GLuint shader, GLsizei count, const GLchar** string, const GLint* length)
+{
+    gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+    GLESv2Debugger::Message msg, cmd;
+    msg.set_context_id(0);
+    msg.set_has_next_message(true);
+    const bool expectResponse = false;
+    msg.set_expect_response(expectResponse);
+    msg.set_function(GLESv2Debugger::Message_Function_glShaderSource);
+    msg.set_arg0(shader);
+    msg.set_arg1(count);
+    msg.set_arg2((int)string);
+    msg.set_arg3((int)length);
+
+    std::string data;
+    for (unsigned i = 0; i < count; i++)
+        if (!length || length[i] < 0)
+            data.append(string[i]);
+        else
+            data.append(string[i], length[i]);
+    msg.set_data(data);
+
+    Send(msg, cmd);
+    if (!expectResponse)
+        cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+    while (true) {
+        msg.Clear();
+        clock_t c0 = clock();
+        switch (cmd.function()) {
+        case GLESv2Debugger::Message_Function_CONTINUE:
+            _c->glShaderSource(shader, count, string, length);
+            msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+            msg.set_context_id(0);
+            msg.set_function(GLESv2Debugger::Message_Function_glShaderSource);
+            msg.set_has_next_message(false);
+            msg.set_expect_response(expectResponse);
+            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;
+        }
+    }
+}
diff --git a/opengl/libs/GLES2_dbg/src/texture.cpp b/opengl/libs/GLES2_dbg/src/texture.cpp
new file mode 100644
index 0000000..a149487
--- /dev/null
+++ b/opengl/libs/GLES2_dbg/src/texture.cpp
@@ -0,0 +1,300 @@
+/*
+ ** 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"
+
+static inline void GetFormatAndBytesPerPixel(const GLenum format, unsigned & bytesPerPixel)
+{
+    switch (format) {
+    case GL_ALPHA:
+        bytesPerPixel = 1;
+        break;
+    case GL_LUMINANCE:
+        bytesPerPixel = 1;
+        break;
+    case GL_LUMINANCE_ALPHA:
+        bytesPerPixel = 2;
+        break;
+    case GL_RGB:
+        bytesPerPixel = 3;
+        break;
+    case GL_RGBA:
+        bytesPerPixel = 4;
+        break;
+
+        // internal formats to avoid conversion
+    case GL_UNSIGNED_SHORT_5_6_5:
+        bytesPerPixel = 2;
+        break;
+    case GL_UNSIGNED_SHORT_4_4_4_4:
+        bytesPerPixel = 2;
+        break;
+    case GL_UNSIGNED_SHORT_5_5_5_1:
+        bytesPerPixel = 2;
+        break;
+    default:
+        assert(0);
+        return;
+    }
+}
+
+#define USE_RLE 0
+#if USE_RLE
+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 > 127)
+                break;
+        if (!repeat) {
+            // find literal length
+            for (run = 1; run < count; run++)
+                if (data[run - 1] == data[run])
+                    break;
+                else if (run > 127)
+                    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
+
+void API_ENTRY(glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width,
+                             GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+//    LOGD("\n*\n* GLESv2_dbg: %s \n*", "glTexImage2D");
+    gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+
+    GLESv2Debugger::Message msg, cmd;
+    msg.set_context_id(0);
+    msg.set_has_next_message(true);
+    const bool expectResponse = false;
+    msg.set_expect_response(expectResponse);
+    msg.set_function(GLESv2Debugger::Message_Function_glTexImage2D);
+
+    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);
+
+    if (pixels) {
+        assert(internalformat == format);
+        assert(0 == border);
+
+        GLenum newFormat = internalformat;
+        switch (type) {
+        case GL_UNSIGNED_BYTE:
+            break;
+        case GL_UNSIGNED_SHORT_5_6_5:
+        case GL_UNSIGNED_SHORT_4_4_4_4:
+        case GL_UNSIGNED_SHORT_5_5_5_1:
+            newFormat = type;
+            break;
+        default:
+            LOGD("GLESv2_dbg: glTexImage2D type=0x%.4X", type);
+            assert(0);
+        }
+        unsigned bytesPerPixel = 0;
+        GetFormatAndBytesPerPixel(newFormat, bytesPerPixel);
+        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
+    }
+    assert(msg.has_arg3());
+    Send(msg, cmd);
+    if (!expectResponse)
+        cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+
+    while (true) {
+        msg.Clear();
+        clock_t c0 = clock();
+        switch (cmd.function()) {
+        case GLESv2Debugger::Message_Function_CONTINUE:
+            _c->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+            msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+            msg.set_context_id(0);
+            msg.set_function(GLESv2Debugger::Message_Function_glTexImage2D);
+            msg.set_has_next_message(false);
+            msg.set_expect_response(expectResponse);
+            assert(!msg.has_arg3());
+            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 API_ENTRY(glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+                                    GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
+{
+//    LOGD("\n*\n* GLESv2_dbg: %s \n*", "glTexSubImage2D");
+    gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;
+
+    GLESv2Debugger::Message msg, cmd;
+    msg.set_context_id(0);
+    msg.set_has_next_message(true);
+    const bool expectResponse = false;
+    msg.set_expect_response(expectResponse);
+    msg.set_function(GLESv2Debugger::Message_Function_glTexSubImage2D);
+
+    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);
+
+    assert(pixels);
+    if (pixels) {
+        GLenum newFormat = format;
+        switch (type) {
+        case GL_UNSIGNED_BYTE:
+            break;
+        case GL_UNSIGNED_SHORT_5_6_5:
+        case GL_UNSIGNED_SHORT_4_4_4_4:
+        case GL_UNSIGNED_SHORT_5_5_5_1:
+            newFormat = type;
+            break;
+        default:
+            assert(0);
+        }
+        unsigned bytesPerPixel = 0;
+        GetFormatAndBytesPerPixel(newFormat, bytesPerPixel);
+        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
+    }
+
+    Send(msg, cmd);
+    if (!expectResponse)
+        cmd.set_function(GLESv2Debugger::Message_Function_CONTINUE);
+
+    while (true) {
+        msg.Clear();
+        clock_t c0 = clock();
+        switch (cmd.function()) {
+        case GLESv2Debugger::Message_Function_CONTINUE:
+            _c->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+            msg.set_time((float(clock()) - c0) / CLOCKS_PER_SEC);
+            msg.set_function(GLESv2Debugger::Message_Function_glTexImage2D);
+            msg.set_context_id(0);
+            msg.set_has_next_message(false);
+            msg.set_expect_response(expectResponse);
+            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;
+        }
+    }
+}
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)