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>
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;
+ }
+ }
+}