From 5d710c26291dc473c892843c268176f837cd3edd Mon Sep 17 00:00:00 2001 From: David Li Date: Fri, 4 Mar 2011 17:47:18 -0800 Subject: [PATCH 1/2] Initial commit of OpenGL ES 2.0 Debugger Client Displays GL call parameters, textures, screen captures and shader source. Server code is in frameworks/base/opengl/libs/GLES2_dbg. Protobuf code is generated using generate_debugger_message_proto.py in server code. Change-Id: Ibe105b60dbe59af84f721c077d2c138a4d04767e Signed-off-by: David Li --- tools/glesv2debugger/.classpath | 8 + tools/glesv2debugger/.project | 28 + tools/glesv2debugger/META-INF/MANIFEST.MF | 12 + tools/glesv2debugger/build.properties | 8 + tools/glesv2debugger/contexts.xml | 12 + tools/glesv2debugger/generate_GLEnum_java.py | 73 + .../generate_GLFunction_java.py | 67 + .../generate_MessageFormatter_java.py | 249 +++ tools/glesv2debugger/icons/sample.gif | Bin 0 -> 983 bytes .../lib/host-libprotobuf-java-2.3.0-lite.jar | Bin 0 -> 50437 bytes tools/glesv2debugger/plugin.xml | 34 + tools/glesv2debugger/src/META-INF/MANIFEST.MF | 3 + .../com/android/glesv2debugger/Activator.java | 81 + .../glesv2debugger/DebuggerMessage.java | 1463 +++++++++++++++++ .../com/android/glesv2debugger/GLEnum.java | 632 +++++++ .../android/glesv2debugger/GLFunction.java | 173 ++ .../android/glesv2debugger/MessageData.java | 89 + .../glesv2debugger/MessageFormatter.java | 396 +++++ .../glesv2debugger/MessageProcessor.java | 148 ++ .../android/glesv2debugger/MessageQueue.java | 263 +++ .../android/glesv2debugger/SampleView.java | 587 +++++++ 21 files changed, 4326 insertions(+) create mode 100755 tools/glesv2debugger/.classpath create mode 100755 tools/glesv2debugger/.project create mode 100755 tools/glesv2debugger/META-INF/MANIFEST.MF create mode 100755 tools/glesv2debugger/build.properties create mode 100755 tools/glesv2debugger/contexts.xml create mode 100755 tools/glesv2debugger/generate_GLEnum_java.py create mode 100755 tools/glesv2debugger/generate_GLFunction_java.py create mode 100755 tools/glesv2debugger/generate_MessageFormatter_java.py create mode 100755 tools/glesv2debugger/icons/sample.gif create mode 100644 tools/glesv2debugger/lib/host-libprotobuf-java-2.3.0-lite.jar create mode 100755 tools/glesv2debugger/plugin.xml create mode 100644 tools/glesv2debugger/src/META-INF/MANIFEST.MF create mode 100755 tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/DebuggerMessage.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/GLEnum.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/GLFunction.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/MessageFormatter.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java create mode 100755 tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java diff --git a/tools/glesv2debugger/.classpath b/tools/glesv2debugger/.classpath new file mode 100755 index 000000000..1ef2c2042 --- /dev/null +++ b/tools/glesv2debugger/.classpath @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/tools/glesv2debugger/.project b/tools/glesv2debugger/.project new file mode 100755 index 000000000..0c974ca50 --- /dev/null +++ b/tools/glesv2debugger/.project @@ -0,0 +1,28 @@ + + + GLESv2DebuggerClient + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff --git a/tools/glesv2debugger/META-INF/MANIFEST.MF b/tools/glesv2debugger/META-INF/MANIFEST.MF new file mode 100755 index 000000000..70b330f55 --- /dev/null +++ b/tools/glesv2debugger/META-INF/MANIFEST.MF @@ -0,0 +1,12 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: GLESv2DebuggerClient +Bundle-SymbolicName: GLESv2DebuggerClient; singleton:=true +Bundle-Version: 1.0.0.qualifier +Bundle-Activator: com.android.glesv2debugger.Activator +Require-Bundle: org.eclipse.ui, + org.eclipse.core.runtime +Bundle-ActivationPolicy: lazy +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 +Bundle-ClassPath: lib/host-libprotobuf-java-2.3.0-lite.jar, + . diff --git a/tools/glesv2debugger/build.properties b/tools/glesv2debugger/build.properties new file mode 100755 index 000000000..6272a3695 --- /dev/null +++ b/tools/glesv2debugger/build.properties @@ -0,0 +1,8 @@ +source.. = src/ +output.. = bin/ +bin.includes = plugin.xml,\ + META-INF/,\ + .,\ + icons/,\ + contexts.xml,\ + lib/host-libprotobuf-java-2.3.0-lite.jar diff --git a/tools/glesv2debugger/contexts.xml b/tools/glesv2debugger/contexts.xml new file mode 100755 index 000000000..02e26e45c --- /dev/null +++ b/tools/glesv2debugger/contexts.xml @@ -0,0 +1,12 @@ + + + This is the context help for the sample view with a table viewer. It was generated by a PDE template. + + + + + + + + + diff --git a/tools/glesv2debugger/generate_GLEnum_java.py b/tools/glesv2debugger/generate_GLEnum_java.py new file mode 100755 index 000000000..cf543c8e9 --- /dev/null +++ b/tools/glesv2debugger/generate_GLEnum_java.py @@ -0,0 +1,73 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# Copyright 2011, The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if __name__ == "__main__": + externs = [] + lines = open("../../../frameworks/base/opengl/libs/enums.in").readlines() + output = open("src/com/android/glesv2debugger/GLEnum.java", "w") + i = 0 + output.write( +"""/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_GLEnum_java.py" + +package com.android.glesv2debugger; + +public enum GLEnum { +""") + + index = 0 + for line in lines: + value = line[line.find("(") + 1: line.find(",")] + name = line[line.find(",") + 1: line.find(")")] + output.write(" %s(%s),\n" % (name, value)) + + output.write(""" ; + + public final int value; + GLEnum(final int value) { + this.value = value; + } + + private static final java.util.HashMap reverseMap = new java.util.HashMap(); + static { + for (GLEnum e : GLEnum.values()) + reverseMap.put(e.value, e); + } + + public static GLEnum valueOf(final int value) { + return reverseMap.get(value); + } +}""") + + diff --git a/tools/glesv2debugger/generate_GLFunction_java.py b/tools/glesv2debugger/generate_GLFunction_java.py new file mode 100755 index 000000000..da0569095 --- /dev/null +++ b/tools/glesv2debugger/generate_GLFunction_java.py @@ -0,0 +1,67 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# Copyright 2011, The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if __name__ == "__main__": + externs = [] + lines = open("../../../frameworks/base/opengl/libs/GLES2_dbg/gl2_api_annotated.in").readlines() + output = open("src/com/android/glesv2debugger/GLFunction.java", "w") + i = 0 + output.write( +"""/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_GLFunction_java.py" + +package com.android.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 + output.write(" %s(%d, DebuggerMessage.Message.Function.%s),\n" % (functionName, index, functionName)) + index += 1 + output.write(""" ; + + public final int index; + public final DebuggerMessage.Message.Function function; + + GLFunction(final int index, final DebuggerMessage.Message.Function function) { + this.index = index; + this.function = function; + } +}""") + + diff --git a/tools/glesv2debugger/generate_MessageFormatter_java.py b/tools/glesv2debugger/generate_MessageFormatter_java.py new file mode 100755 index 000000000..b6c67a9ad --- /dev/null +++ b/tools/glesv2debugger/generate_MessageFormatter_java.py @@ -0,0 +1,249 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# +# Copyright 2011, The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import os +import sys + +def RemoveAnnotation(line): + if line.find(":") >= 0: + annotation = line[line.find(":"): line.find(" ", line.find(":"))] + return line.replace(annotation, "*") + else: + return line + +if __name__ == "__main__": + externs = [] + lines = open("../../../frameworks/base/opengl/libs/GLES2_dbg/gl2_api_annotated.in").readlines() + output = open("src/com/android/glesv2debugger/MessageFormatter.java", "w") + + i = 0 + output.write( +"""/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_MessageFormatter_java.py" + +package com.android.glesv2debugger; + +import java.nio.ByteBuffer; + +public class MessageFormatter { + + static String FormatFloats(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Float.intBitsToFloat(Integer.reverseBytes(data.getInt())); + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatInts(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Integer.reverseBytes(data.getInt()); + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatUints(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + long bits = Integer.reverseBytes(data.getInt()) & 0xffffffff; + ret += bits; + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatMatrix(int columns, int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Float.intBitsToFloat(Integer.reverseBytes(data.getInt())); + if (i % columns == columns - 1) + ret += '\\n'; + else if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + public static String Format(final DebuggerMessage.Message msg) { + String str; + switch (msg.getFunction()) { +""") + + 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(") {")] + + 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 = [] + inout = "" + + paramNames = [] + + 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 inout == "" # only one parameter should be annotated + inout = paramType.split(":")[2] + annotation = paramType.split(":")[1] + paramType = paramType.split(":")[0] + count = 1 + countArg = "" + if annotation.find("*") >= 0: # [1,n] * param + count = int(annotation.split("*")[0]) + countArg = annotation.split("*")[1] + assert countArg in paramNames + elif annotation in paramNames: + count = 1 + countArg = annotation + elif annotation == "GLstring": + annotation = 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" + elif paramType.find("void") >= 0: + assert 1 + 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().asReadOnlyByteBuffer())" % (columns, count, paramNames.index(countArg)) + elif annotation == "GLstring": + formatArgs += ", msg.getData().toStringUtf8()" + elif paramType.find("void") >= 0: + formatArgs += ', "0x" + Integer.toHexString(msg.getArg%d())' % (paramIndex) + elif countArg == "": + formatArgs += ", %s(%d, msg.getData().asReadOnlyByteBuffer())" % (dataFormatter, count) + else: + formatArgs += ", %s(%d * msg.getArg%d(), msg.getData().asReadOnlyByteBuffer())" % (dataFormatter, count, paramNames.index(countArg)) + else: + 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 += ", " + paramNames.append(paramName) + paramIndex += 1 + + + formatString += ")" + + output.write(" case %s:\n" % (functionName)) + if line.find("*") >= 0 and (line.find("*") < line.find(":") or line.find("*") > line.rfind(":")): + sys.stderr.write(line) + output.write(" // FIXME: this function uses pointers, debugger may send data in msg.data\n") + output.write(' str = String.format("%s", %s); break;\n' % (formatString, formatArgs)) + + + output.write(""" default: + str = msg.toString(); + } + return str; + } +}""") + +''' print """/* +package GLESv2Debugger; + +public class MessageFormatterCustom { + + public static String Format(final DebuggerMessage.Message msg) { + String str; + switch (msg.getFunction()) {""" + + for extern in externs: + print " case %s" % (extern) + print " // TODO:" + +print """ default: + str = msg.toString(); + } + return str; + } +} +*/""" ''' + + diff --git a/tools/glesv2debugger/icons/sample.gif b/tools/glesv2debugger/icons/sample.gif new file mode 100755 index 0000000000000000000000000000000000000000..34fb3c9d8cb7d489681b7f7aee4bdcd7eaf53610 GIT binary patch literal 983 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 a{BmR@FAV|t1C$o + + + + + + + + + + + + + + + + + + + diff --git a/tools/glesv2debugger/src/META-INF/MANIFEST.MF b/tools/glesv2debugger/src/META-INF/MANIFEST.MF new file mode 100644 index 000000000..212b27a43 --- /dev/null +++ b/tools/glesv2debugger/src/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +Created-By: 1.6.0_22 (Sun Microsystems Inc.) + diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java b/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java new file mode 100755 index 000000000..f859510d5 --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java @@ -0,0 +1,81 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.osgi.framework.BundleContext; + +/** + * The activator class controls the plug-in life cycle + */ +public class Activator extends AbstractUIPlugin { + + // The plug-in ID + public static final String PLUGIN_ID = "GLESv2DebuggerClient"; //$NON-NLS-1$ + + // The shared instance + private static Activator plugin; + + /** + * The constructor + */ + public Activator() { + } + + /* + * (non-Javadoc) + * @see + * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext + * ) + */ + public void start(BundleContext context) throws Exception { + super.start(context); + plugin = this; + } + + /* + * (non-Javadoc) + * @see + * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext + * ) + */ + public void stop(BundleContext context) throws Exception { + plugin = null; + super.stop(context); + } + + /** + * Returns the shared instance + * + * @return the shared instance + */ + public static Activator getDefault() { + return plugin; + } + + /** + * Returns an image descriptor for the image file at the given plug-in + * relative path + * + * @param path the path + * @return the image descriptor + */ + public static ImageDescriptor getImageDescriptor(String path) { + return imageDescriptorFromPlugin(PLUGIN_ID, path); + } +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/DebuggerMessage.java b/tools/glesv2debugger/src/com/android/glesv2debugger/DebuggerMessage.java new file mode 100644 index 000000000..fa1d7eda1 --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/DebuggerMessage.java @@ -0,0 +1,1463 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: debugger_message.proto + +package com.android.glesv2debugger; + +public final class DebuggerMessage { + private DebuggerMessage() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + public static final class Message extends + com.google.protobuf.GeneratedMessageLite { + // Use Message.newBuilder() to construct. + private Message() { + initFields(); + } + private Message(boolean noInit) {} + + private static final Message defaultInstance; + public static Message getDefaultInstance() { + return defaultInstance; + } + + public Message getDefaultInstanceForType() { + return defaultInstance; + } + + public enum Function + implements com.google.protobuf.Internal.EnumLite { + glActiveTexture(0, 0), + glAttachShader(1, 1), + glBindAttribLocation(2, 2), + glBindBuffer(3, 3), + glBindFramebuffer(4, 4), + glBindRenderbuffer(5, 5), + glBindTexture(6, 6), + glBlendColor(7, 7), + glBlendEquation(8, 8), + glBlendEquationSeparate(9, 9), + glBlendFunc(10, 10), + glBlendFuncSeparate(11, 11), + glBufferData(12, 12), + glBufferSubData(13, 13), + glCheckFramebufferStatus(14, 14), + glClear(15, 15), + glClearColor(16, 16), + glClearDepthf(17, 17), + glClearStencil(18, 18), + glColorMask(19, 19), + glCompileShader(20, 20), + glCompressedTexImage2D(21, 21), + glCompressedTexSubImage2D(22, 22), + glCopyTexImage2D(23, 23), + glCopyTexSubImage2D(24, 24), + glCreateProgram(25, 25), + glCreateShader(26, 26), + glCullFace(27, 27), + glDeleteBuffers(28, 28), + glDeleteFramebuffers(29, 29), + glDeleteProgram(30, 30), + glDeleteRenderbuffers(31, 31), + glDeleteShader(32, 32), + glDeleteTextures(33, 33), + glDepthFunc(34, 34), + glDepthMask(35, 35), + glDepthRangef(36, 36), + glDetachShader(37, 37), + glDisable(38, 38), + glDisableVertexAttribArray(39, 39), + glDrawArrays(40, 40), + glDrawElements(41, 41), + glEnable(42, 42), + glEnableVertexAttribArray(43, 43), + glFinish(44, 44), + glFlush(45, 45), + glFramebufferRenderbuffer(46, 46), + glFramebufferTexture2D(47, 47), + glFrontFace(48, 48), + glGenBuffers(49, 49), + glGenerateMipmap(50, 50), + glGenFramebuffers(51, 51), + glGenRenderbuffers(52, 52), + glGenTextures(53, 53), + glGetActiveAttrib(54, 54), + glGetActiveUniform(55, 55), + glGetAttachedShaders(56, 56), + glGetAttribLocation(57, 57), + glGetBooleanv(58, 58), + glGetBufferParameteriv(59, 59), + glGetError(60, 60), + glGetFloatv(61, 61), + glGetFramebufferAttachmentParameteriv(62, 62), + glGetIntegerv(63, 63), + glGetProgramiv(64, 64), + glGetProgramInfoLog(65, 65), + glGetRenderbufferParameteriv(66, 66), + glGetShaderiv(67, 67), + glGetShaderInfoLog(68, 68), + glGetShaderPrecisionFormat(69, 69), + glGetShaderSource(70, 70), + glGetString(71, 71), + glGetTexParameterfv(72, 72), + glGetTexParameteriv(73, 73), + glGetUniformfv(74, 74), + glGetUniformiv(75, 75), + glGetUniformLocation(76, 76), + glGetVertexAttribfv(77, 77), + glGetVertexAttribiv(78, 78), + glGetVertexAttribPointerv(79, 79), + glHint(80, 80), + glIsBuffer(81, 81), + glIsEnabled(82, 82), + glIsFramebuffer(83, 83), + glIsProgram(84, 84), + glIsRenderbuffer(85, 85), + glIsShader(86, 86), + glIsTexture(87, 87), + glLineWidth(88, 88), + glLinkProgram(89, 89), + glPixelStorei(90, 90), + glPolygonOffset(91, 91), + glReadPixels(92, 92), + glReleaseShaderCompiler(93, 93), + glRenderbufferStorage(94, 94), + glSampleCoverage(95, 95), + glScissor(96, 96), + glShaderBinary(97, 97), + glShaderSource(98, 98), + glStencilFunc(99, 99), + glStencilFuncSeparate(100, 100), + glStencilMask(101, 101), + glStencilMaskSeparate(102, 102), + glStencilOp(103, 103), + glStencilOpSeparate(104, 104), + glTexImage2D(105, 105), + glTexParameterf(106, 106), + glTexParameterfv(107, 107), + glTexParameteri(108, 108), + glTexParameteriv(109, 109), + glTexSubImage2D(110, 110), + glUniform1f(111, 111), + glUniform1fv(112, 112), + glUniform1i(113, 113), + glUniform1iv(114, 114), + glUniform2f(115, 115), + glUniform2fv(116, 116), + glUniform2i(117, 117), + glUniform2iv(118, 118), + glUniform3f(119, 119), + glUniform3fv(120, 120), + glUniform3i(121, 121), + glUniform3iv(122, 122), + glUniform4f(123, 123), + glUniform4fv(124, 124), + glUniform4i(125, 125), + glUniform4iv(126, 126), + glUniformMatrix2fv(127, 127), + glUniformMatrix3fv(128, 128), + glUniformMatrix4fv(129, 129), + glUseProgram(130, 130), + glValidateProgram(131, 131), + glVertexAttrib1f(132, 132), + glVertexAttrib1fv(133, 133), + glVertexAttrib2f(134, 134), + glVertexAttrib2fv(135, 135), + glVertexAttrib3f(136, 136), + glVertexAttrib3fv(137, 137), + glVertexAttrib4f(138, 138), + glVertexAttrib4fv(139, 139), + glVertexAttribPointer(140, 140), + glViewport(141, 141), + eglGetDisplay(142, 142), + eglInitialize(143, 143), + eglTerminate(144, 144), + eglGetConfigs(145, 145), + eglChooseConfig(146, 146), + eglGetConfigAttrib(147, 147), + eglCreateWindowSurface(148, 148), + eglCreatePixmapSurface(149, 149), + eglCreatePbufferSurface(150, 150), + eglDestroySurface(151, 151), + eglQuerySurface(152, 152), + eglCreateContext(153, 153), + eglDestroyContext(154, 154), + eglMakeCurrent(155, 155), + eglGetCurrentContext(156, 156), + eglGetCurrentSurface(157, 157), + eglGetCurrentDisplay(158, 158), + eglQueryContext(159, 159), + eglWaitGL(160, 160), + eglWaitNative(161, 161), + eglSwapBuffers(162, 162), + eglCopyBuffers(163, 163), + eglGetError(164, 164), + eglQueryString(165, 165), + eglGetProcAddress(166, 166), + eglSurfaceAttrib(167, 167), + eglBindTexImage(168, 168), + eglReleaseTexImage(169, 169), + eglSwapInterval(170, 170), + eglBindAPI(171, 171), + eglQueryAPI(172, 172), + eglWaitClient(173, 173), + eglReleaseThread(174, 174), + eglCreatePbufferFromClientBuffer(175, 175), + eglLockSurfaceKHR(176, 176), + eglUnlockSurfaceKHR(177, 177), + eglCreateImageKHR(178, 178), + eglDestroyImageKHR(179, 179), + eglCreateSyncKHR(180, 180), + eglDestroySyncKHR(181, 181), + eglClientWaitSyncKHR(182, 182), + eglGetSyncAttribKHR(183, 183), + eglSetSwapRectangleANDROID(184, 184), + eglGetRenderBufferANDROID(185, 185), + ACK(186, 186), + NEG(187, 187), + CONTINUE(188, 188), + SKIP(189, 189), + SETPROP(190, 190), + CAPTURE(191, 191), + ; + + + public final int getNumber() { return value; } + + public static Function valueOf(int value) { + switch (value) { + case 0: return glActiveTexture; + case 1: return glAttachShader; + case 2: return glBindAttribLocation; + case 3: return glBindBuffer; + case 4: return glBindFramebuffer; + case 5: return glBindRenderbuffer; + case 6: return glBindTexture; + case 7: return glBlendColor; + case 8: return glBlendEquation; + case 9: return glBlendEquationSeparate; + case 10: return glBlendFunc; + case 11: return glBlendFuncSeparate; + case 12: return glBufferData; + case 13: return glBufferSubData; + case 14: return glCheckFramebufferStatus; + case 15: return glClear; + case 16: return glClearColor; + case 17: return glClearDepthf; + case 18: return glClearStencil; + case 19: return glColorMask; + case 20: return glCompileShader; + case 21: return glCompressedTexImage2D; + case 22: return glCompressedTexSubImage2D; + case 23: return glCopyTexImage2D; + case 24: return glCopyTexSubImage2D; + case 25: return glCreateProgram; + case 26: return glCreateShader; + case 27: return glCullFace; + case 28: return glDeleteBuffers; + case 29: return glDeleteFramebuffers; + case 30: return glDeleteProgram; + case 31: return glDeleteRenderbuffers; + case 32: return glDeleteShader; + case 33: return glDeleteTextures; + case 34: return glDepthFunc; + case 35: return glDepthMask; + case 36: return glDepthRangef; + case 37: return glDetachShader; + case 38: return glDisable; + case 39: return glDisableVertexAttribArray; + case 40: return glDrawArrays; + case 41: return glDrawElements; + case 42: return glEnable; + case 43: return glEnableVertexAttribArray; + case 44: return glFinish; + case 45: return glFlush; + case 46: return glFramebufferRenderbuffer; + case 47: return glFramebufferTexture2D; + case 48: return glFrontFace; + case 49: return glGenBuffers; + case 50: return glGenerateMipmap; + case 51: return glGenFramebuffers; + case 52: return glGenRenderbuffers; + case 53: return glGenTextures; + case 54: return glGetActiveAttrib; + case 55: return glGetActiveUniform; + case 56: return glGetAttachedShaders; + case 57: return glGetAttribLocation; + case 58: return glGetBooleanv; + case 59: return glGetBufferParameteriv; + case 60: return glGetError; + case 61: return glGetFloatv; + case 62: return glGetFramebufferAttachmentParameteriv; + case 63: return glGetIntegerv; + case 64: return glGetProgramiv; + case 65: return glGetProgramInfoLog; + case 66: return glGetRenderbufferParameteriv; + case 67: return glGetShaderiv; + case 68: return glGetShaderInfoLog; + case 69: return glGetShaderPrecisionFormat; + case 70: return glGetShaderSource; + case 71: return glGetString; + case 72: return glGetTexParameterfv; + case 73: return glGetTexParameteriv; + case 74: return glGetUniformfv; + case 75: return glGetUniformiv; + case 76: return glGetUniformLocation; + case 77: return glGetVertexAttribfv; + case 78: return glGetVertexAttribiv; + case 79: return glGetVertexAttribPointerv; + case 80: return glHint; + case 81: return glIsBuffer; + case 82: return glIsEnabled; + case 83: return glIsFramebuffer; + case 84: return glIsProgram; + case 85: return glIsRenderbuffer; + case 86: return glIsShader; + case 87: return glIsTexture; + case 88: return glLineWidth; + case 89: return glLinkProgram; + case 90: return glPixelStorei; + case 91: return glPolygonOffset; + case 92: return glReadPixels; + case 93: return glReleaseShaderCompiler; + case 94: return glRenderbufferStorage; + case 95: return glSampleCoverage; + case 96: return glScissor; + case 97: return glShaderBinary; + case 98: return glShaderSource; + case 99: return glStencilFunc; + case 100: return glStencilFuncSeparate; + case 101: return glStencilMask; + case 102: return glStencilMaskSeparate; + case 103: return glStencilOp; + case 104: return glStencilOpSeparate; + case 105: return glTexImage2D; + case 106: return glTexParameterf; + case 107: return glTexParameterfv; + case 108: return glTexParameteri; + case 109: return glTexParameteriv; + case 110: return glTexSubImage2D; + case 111: return glUniform1f; + case 112: return glUniform1fv; + case 113: return glUniform1i; + case 114: return glUniform1iv; + case 115: return glUniform2f; + case 116: return glUniform2fv; + case 117: return glUniform2i; + case 118: return glUniform2iv; + case 119: return glUniform3f; + case 120: return glUniform3fv; + case 121: return glUniform3i; + case 122: return glUniform3iv; + case 123: return glUniform4f; + case 124: return glUniform4fv; + case 125: return glUniform4i; + case 126: return glUniform4iv; + case 127: return glUniformMatrix2fv; + case 128: return glUniformMatrix3fv; + case 129: return glUniformMatrix4fv; + case 130: return glUseProgram; + case 131: return glValidateProgram; + case 132: return glVertexAttrib1f; + case 133: return glVertexAttrib1fv; + case 134: return glVertexAttrib2f; + case 135: return glVertexAttrib2fv; + case 136: return glVertexAttrib3f; + case 137: return glVertexAttrib3fv; + case 138: return glVertexAttrib4f; + case 139: return glVertexAttrib4fv; + case 140: return glVertexAttribPointer; + case 141: return glViewport; + case 142: return eglGetDisplay; + case 143: return eglInitialize; + case 144: return eglTerminate; + case 145: return eglGetConfigs; + case 146: return eglChooseConfig; + case 147: return eglGetConfigAttrib; + case 148: return eglCreateWindowSurface; + case 149: return eglCreatePixmapSurface; + case 150: return eglCreatePbufferSurface; + case 151: return eglDestroySurface; + case 152: return eglQuerySurface; + case 153: return eglCreateContext; + case 154: return eglDestroyContext; + case 155: return eglMakeCurrent; + case 156: return eglGetCurrentContext; + case 157: return eglGetCurrentSurface; + case 158: return eglGetCurrentDisplay; + case 159: return eglQueryContext; + case 160: return eglWaitGL; + case 161: return eglWaitNative; + case 162: return eglSwapBuffers; + case 163: return eglCopyBuffers; + case 164: return eglGetError; + case 165: return eglQueryString; + case 166: return eglGetProcAddress; + case 167: return eglSurfaceAttrib; + case 168: return eglBindTexImage; + case 169: return eglReleaseTexImage; + case 170: return eglSwapInterval; + case 171: return eglBindAPI; + case 172: return eglQueryAPI; + case 173: return eglWaitClient; + case 174: return eglReleaseThread; + case 175: return eglCreatePbufferFromClientBuffer; + case 176: return eglLockSurfaceKHR; + case 177: return eglUnlockSurfaceKHR; + case 178: return eglCreateImageKHR; + case 179: return eglDestroyImageKHR; + case 180: return eglCreateSyncKHR; + case 181: return eglDestroySyncKHR; + case 182: return eglClientWaitSyncKHR; + case 183: return eglGetSyncAttribKHR; + case 184: return eglSetSwapRectangleANDROID; + case 185: return eglGetRenderBufferANDROID; + case 186: return ACK; + case 187: return NEG; + case 188: return CONTINUE; + case 189: return SKIP; + case 190: return SETPROP; + case 191: return CAPTURE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Function findValueByNumber(int number) { + return Function.valueOf(number) + ; } + }; + + private final int index; + private final int value; + private Function(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:com.android.glesv2debugger.Message.Function) + } + + public enum Type + implements com.google.protobuf.Internal.EnumLite { + BeforeCall(0, 0), + AfterCall(1, 1), + Response(2, 2), + ; + + + public final int getNumber() { return value; } + + public static Type valueOf(int value) { + switch (value) { + case 0: return BeforeCall; + case 1: return AfterCall; + case 2: return Response; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.valueOf(number) + ; } + }; + + private final int index; + private final int value; + private Type(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:com.android.glesv2debugger.Message.Type) + } + + public enum Prop + implements com.google.protobuf.Internal.EnumLite { + Capture(0, 0), + TimeMode(1, 1), + ; + + + public final int getNumber() { return value; } + + public static Prop valueOf(int value) { + switch (value) { + case 0: return Capture; + case 1: return TimeMode; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Prop findValueByNumber(int number) { + return Prop.valueOf(number) + ; } + }; + + private final int index; + private final int value; + private Prop(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:com.android.glesv2debugger.Message.Prop) + } + + // required int32 context_id = 1; + public static final int CONTEXT_ID_FIELD_NUMBER = 1; + private boolean hasContextId; + private int contextId_ = 0; + public boolean hasContextId() { return hasContextId; } + public int getContextId() { return contextId_; } + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + public static final int FUNCTION_FIELD_NUMBER = 2; + private boolean hasFunction; + private com.android.glesv2debugger.DebuggerMessage.Message.Function function_; + public boolean hasFunction() { return hasFunction; } + public com.android.glesv2debugger.DebuggerMessage.Message.Function getFunction() { return function_; } + + // required .com.android.glesv2debugger.Message.Type type = 3; + public static final int TYPE_FIELD_NUMBER = 3; + private boolean hasType; + private com.android.glesv2debugger.DebuggerMessage.Message.Type type_; + public boolean hasType() { return hasType; } + public com.android.glesv2debugger.DebuggerMessage.Message.Type getType() { return type_; } + + // required bool expect_response = 4; + public static final int EXPECT_RESPONSE_FIELD_NUMBER = 4; + private boolean hasExpectResponse; + private boolean expectResponse_ = false; + public boolean hasExpectResponse() { return hasExpectResponse; } + public boolean getExpectResponse() { return expectResponse_; } + + // optional int32 ret = 5; + public static final int RET_FIELD_NUMBER = 5; + private boolean hasRet; + private int ret_ = 0; + public boolean hasRet() { return hasRet; } + public int getRet() { return ret_; } + + // optional int32 arg0 = 6; + public static final int ARG0_FIELD_NUMBER = 6; + private boolean hasArg0; + private int arg0_ = 0; + public boolean hasArg0() { return hasArg0; } + public int getArg0() { return arg0_; } + + // optional int32 arg1 = 7; + public static final int ARG1_FIELD_NUMBER = 7; + private boolean hasArg1; + private int arg1_ = 0; + public boolean hasArg1() { return hasArg1; } + public int getArg1() { return arg1_; } + + // optional int32 arg2 = 8; + public static final int ARG2_FIELD_NUMBER = 8; + private boolean hasArg2; + private int arg2_ = 0; + public boolean hasArg2() { return hasArg2; } + public int getArg2() { return arg2_; } + + // optional int32 arg3 = 9; + public static final int ARG3_FIELD_NUMBER = 9; + private boolean hasArg3; + private int arg3_ = 0; + public boolean hasArg3() { return hasArg3; } + public int getArg3() { return arg3_; } + + // optional int32 arg4 = 16; + public static final int ARG4_FIELD_NUMBER = 16; + private boolean hasArg4; + private int arg4_ = 0; + public boolean hasArg4() { return hasArg4; } + public int getArg4() { return arg4_; } + + // optional int32 arg5 = 17; + public static final int ARG5_FIELD_NUMBER = 17; + private boolean hasArg5; + private int arg5_ = 0; + public boolean hasArg5() { return hasArg5; } + public int getArg5() { return arg5_; } + + // optional int32 arg6 = 18; + public static final int ARG6_FIELD_NUMBER = 18; + private boolean hasArg6; + private int arg6_ = 0; + public boolean hasArg6() { return hasArg6; } + public int getArg6() { return arg6_; } + + // optional int32 arg7 = 19; + public static final int ARG7_FIELD_NUMBER = 19; + private boolean hasArg7; + private int arg7_ = 0; + public boolean hasArg7() { return hasArg7; } + public int getArg7() { return arg7_; } + + // optional int32 arg8 = 20; + public static final int ARG8_FIELD_NUMBER = 20; + private boolean hasArg8; + private int arg8_ = 0; + public boolean hasArg8() { return hasArg8; } + public int getArg8() { return arg8_; } + + // optional bytes data = 10; + public static final int DATA_FIELD_NUMBER = 10; + private boolean hasData; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + public boolean hasData() { return hasData; } + public com.google.protobuf.ByteString getData() { return data_; } + + // optional float time = 11; + public static final int TIME_FIELD_NUMBER = 11; + private boolean hasTime; + private float time_ = 0F; + public boolean hasTime() { return hasTime; } + public float getTime() { return time_; } + + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + public static final int PROP_FIELD_NUMBER = 21; + private boolean hasProp; + private com.android.glesv2debugger.DebuggerMessage.Message.Prop prop_; + public boolean hasProp() { return hasProp; } + public com.android.glesv2debugger.DebuggerMessage.Message.Prop getProp() { return prop_; } + + // optional float clock = 22; + public static final int CLOCK_FIELD_NUMBER = 22; + private boolean hasClock; + private float clock_ = 0F; + public boolean hasClock() { return hasClock; } + public float getClock() { return clock_; } + + private void initFields() { + function_ = com.android.glesv2debugger.DebuggerMessage.Message.Function.NEG; + type_ = com.android.glesv2debugger.DebuggerMessage.Message.Type.BeforeCall; + prop_ = com.android.glesv2debugger.DebuggerMessage.Message.Prop.Capture; + } + public final boolean isInitialized() { + if (!hasContextId) return false; + if (!hasFunction) return false; + if (!hasType) return false; + if (!hasExpectResponse) return false; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (hasContextId()) { + output.writeInt32(1, getContextId()); + } + if (hasFunction()) { + output.writeEnum(2, getFunction().getNumber()); + } + if (hasType()) { + output.writeEnum(3, getType().getNumber()); + } + if (hasExpectResponse()) { + output.writeBool(4, getExpectResponse()); + } + if (hasRet()) { + output.writeInt32(5, getRet()); + } + if (hasArg0()) { + output.writeInt32(6, getArg0()); + } + if (hasArg1()) { + output.writeInt32(7, getArg1()); + } + if (hasArg2()) { + output.writeInt32(8, getArg2()); + } + if (hasArg3()) { + output.writeInt32(9, getArg3()); + } + if (hasData()) { + output.writeBytes(10, getData()); + } + if (hasTime()) { + output.writeFloat(11, getTime()); + } + if (hasArg4()) { + output.writeInt32(16, getArg4()); + } + if (hasArg5()) { + output.writeInt32(17, getArg5()); + } + if (hasArg6()) { + output.writeInt32(18, getArg6()); + } + if (hasArg7()) { + output.writeInt32(19, getArg7()); + } + if (hasArg8()) { + output.writeInt32(20, getArg8()); + } + if (hasProp()) { + output.writeEnum(21, getProp().getNumber()); + } + if (hasClock()) { + output.writeFloat(22, getClock()); + } + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasContextId()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, getContextId()); + } + if (hasFunction()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, getFunction().getNumber()); + } + if (hasType()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, getType().getNumber()); + } + if (hasExpectResponse()) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(4, getExpectResponse()); + } + if (hasRet()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(5, getRet()); + } + if (hasArg0()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(6, getArg0()); + } + if (hasArg1()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(7, getArg1()); + } + if (hasArg2()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(8, getArg2()); + } + if (hasArg3()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(9, getArg3()); + } + if (hasData()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(10, getData()); + } + if (hasTime()) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(11, getTime()); + } + if (hasArg4()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(16, getArg4()); + } + if (hasArg5()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(17, getArg5()); + } + if (hasArg6()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(18, getArg6()); + } + if (hasArg7()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(19, getArg7()); + } + if (hasArg8()) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(20, getArg8()); + } + if (hasProp()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(21, getProp().getNumber()); + } + if (hasClock()) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(22, getClock()); + } + memoizedSerializedSize = size; + return size; + } + + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static com.android.glesv2debugger.DebuggerMessage.Message parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(com.android.glesv2debugger.DebuggerMessage.Message prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + com.android.glesv2debugger.DebuggerMessage.Message, Builder> { + private com.android.glesv2debugger.DebuggerMessage.Message result; + + // Construct using com.android.glesv2debugger.DebuggerMessage.Message.newBuilder() + private Builder() {} + + private static Builder create() { + Builder builder = new Builder(); + builder.result = new com.android.glesv2debugger.DebuggerMessage.Message(); + return builder; + } + + protected com.android.glesv2debugger.DebuggerMessage.Message internalGetResult() { + return result; + } + + public Builder clear() { + if (result == null) { + throw new IllegalStateException( + "Cannot call clear() after build()."); + } + result = new com.android.glesv2debugger.DebuggerMessage.Message(); + return this; + } + + public Builder clone() { + return create().mergeFrom(result); + } + + public com.android.glesv2debugger.DebuggerMessage.Message getDefaultInstanceForType() { + return com.android.glesv2debugger.DebuggerMessage.Message.getDefaultInstance(); + } + + public boolean isInitialized() { + return result.isInitialized(); + } + public com.android.glesv2debugger.DebuggerMessage.Message build() { + if (result != null && !isInitialized()) { + throw newUninitializedMessageException(result); + } + return buildPartial(); + } + + private com.android.glesv2debugger.DebuggerMessage.Message buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + if (!isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return buildPartial(); + } + + public com.android.glesv2debugger.DebuggerMessage.Message buildPartial() { + if (result == null) { + throw new IllegalStateException( + "build() has already been called on this Builder."); + } + com.android.glesv2debugger.DebuggerMessage.Message returnMe = result; + result = null; + return returnMe; + } + + public Builder mergeFrom(com.android.glesv2debugger.DebuggerMessage.Message other) { + if (other == com.android.glesv2debugger.DebuggerMessage.Message.getDefaultInstance()) return this; + if (other.hasContextId()) { + setContextId(other.getContextId()); + } + if (other.hasFunction()) { + setFunction(other.getFunction()); + } + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasExpectResponse()) { + setExpectResponse(other.getExpectResponse()); + } + if (other.hasRet()) { + setRet(other.getRet()); + } + if (other.hasArg0()) { + setArg0(other.getArg0()); + } + if (other.hasArg1()) { + setArg1(other.getArg1()); + } + if (other.hasArg2()) { + setArg2(other.getArg2()); + } + if (other.hasArg3()) { + setArg3(other.getArg3()); + } + if (other.hasArg4()) { + setArg4(other.getArg4()); + } + if (other.hasArg5()) { + setArg5(other.getArg5()); + } + if (other.hasArg6()) { + setArg6(other.getArg6()); + } + if (other.hasArg7()) { + setArg7(other.getArg7()); + } + if (other.hasArg8()) { + setArg8(other.getArg8()); + } + if (other.hasData()) { + setData(other.getData()); + } + if (other.hasTime()) { + setTime(other.getTime()); + } + if (other.hasProp()) { + setProp(other.getProp()); + } + if (other.hasClock()) { + setClock(other.getClock()); + } + return this; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + return this; + } + break; + } + case 8: { + setContextId(input.readInt32()); + break; + } + case 16: { + int rawValue = input.readEnum(); + com.android.glesv2debugger.DebuggerMessage.Message.Function value = com.android.glesv2debugger.DebuggerMessage.Message.Function.valueOf(rawValue); + if (value != null) { + setFunction(value); + } + break; + } + case 24: { + int rawValue = input.readEnum(); + com.android.glesv2debugger.DebuggerMessage.Message.Type value = com.android.glesv2debugger.DebuggerMessage.Message.Type.valueOf(rawValue); + if (value != null) { + setType(value); + } + break; + } + case 32: { + setExpectResponse(input.readBool()); + break; + } + case 40: { + setRet(input.readInt32()); + break; + } + case 48: { + setArg0(input.readInt32()); + break; + } + case 56: { + setArg1(input.readInt32()); + break; + } + case 64: { + setArg2(input.readInt32()); + break; + } + case 72: { + setArg3(input.readInt32()); + break; + } + case 82: { + setData(input.readBytes()); + break; + } + case 93: { + setTime(input.readFloat()); + break; + } + case 128: { + setArg4(input.readInt32()); + break; + } + case 136: { + setArg5(input.readInt32()); + break; + } + case 144: { + setArg6(input.readInt32()); + break; + } + case 152: { + setArg7(input.readInt32()); + break; + } + case 160: { + setArg8(input.readInt32()); + break; + } + case 168: { + int rawValue = input.readEnum(); + com.android.glesv2debugger.DebuggerMessage.Message.Prop value = com.android.glesv2debugger.DebuggerMessage.Message.Prop.valueOf(rawValue); + if (value != null) { + setProp(value); + } + break; + } + case 181: { + setClock(input.readFloat()); + break; + } + } + } + } + + + // required int32 context_id = 1; + public boolean hasContextId() { + return result.hasContextId(); + } + public int getContextId() { + return result.getContextId(); + } + public Builder setContextId(int value) { + result.hasContextId = true; + result.contextId_ = value; + return this; + } + public Builder clearContextId() { + result.hasContextId = false; + result.contextId_ = 0; + return this; + } + + // required .com.android.glesv2debugger.Message.Function function = 2 [default = NEG]; + public boolean hasFunction() { + return result.hasFunction(); + } + public com.android.glesv2debugger.DebuggerMessage.Message.Function getFunction() { + return result.getFunction(); + } + public Builder setFunction(com.android.glesv2debugger.DebuggerMessage.Message.Function value) { + if (value == null) { + throw new NullPointerException(); + } + result.hasFunction = true; + result.function_ = value; + return this; + } + public Builder clearFunction() { + result.hasFunction = false; + result.function_ = com.android.glesv2debugger.DebuggerMessage.Message.Function.NEG; + return this; + } + + // required .com.android.glesv2debugger.Message.Type type = 3; + public boolean hasType() { + return result.hasType(); + } + public com.android.glesv2debugger.DebuggerMessage.Message.Type getType() { + return result.getType(); + } + public Builder setType(com.android.glesv2debugger.DebuggerMessage.Message.Type value) { + if (value == null) { + throw new NullPointerException(); + } + result.hasType = true; + result.type_ = value; + return this; + } + public Builder clearType() { + result.hasType = false; + result.type_ = com.android.glesv2debugger.DebuggerMessage.Message.Type.BeforeCall; + return this; + } + + // required bool expect_response = 4; + public boolean hasExpectResponse() { + return result.hasExpectResponse(); + } + public boolean getExpectResponse() { + return result.getExpectResponse(); + } + public Builder setExpectResponse(boolean value) { + result.hasExpectResponse = true; + result.expectResponse_ = value; + return this; + } + public Builder clearExpectResponse() { + result.hasExpectResponse = false; + result.expectResponse_ = false; + return this; + } + + // optional int32 ret = 5; + public boolean hasRet() { + return result.hasRet(); + } + public int getRet() { + return result.getRet(); + } + public Builder setRet(int value) { + result.hasRet = true; + result.ret_ = value; + return this; + } + public Builder clearRet() { + result.hasRet = false; + result.ret_ = 0; + return this; + } + + // optional int32 arg0 = 6; + public boolean hasArg0() { + return result.hasArg0(); + } + public int getArg0() { + return result.getArg0(); + } + public Builder setArg0(int value) { + result.hasArg0 = true; + result.arg0_ = value; + return this; + } + public Builder clearArg0() { + result.hasArg0 = false; + result.arg0_ = 0; + return this; + } + + // optional int32 arg1 = 7; + public boolean hasArg1() { + return result.hasArg1(); + } + public int getArg1() { + return result.getArg1(); + } + public Builder setArg1(int value) { + result.hasArg1 = true; + result.arg1_ = value; + return this; + } + public Builder clearArg1() { + result.hasArg1 = false; + result.arg1_ = 0; + return this; + } + + // optional int32 arg2 = 8; + public boolean hasArg2() { + return result.hasArg2(); + } + public int getArg2() { + return result.getArg2(); + } + public Builder setArg2(int value) { + result.hasArg2 = true; + result.arg2_ = value; + return this; + } + public Builder clearArg2() { + result.hasArg2 = false; + result.arg2_ = 0; + return this; + } + + // optional int32 arg3 = 9; + public boolean hasArg3() { + return result.hasArg3(); + } + public int getArg3() { + return result.getArg3(); + } + public Builder setArg3(int value) { + result.hasArg3 = true; + result.arg3_ = value; + return this; + } + public Builder clearArg3() { + result.hasArg3 = false; + result.arg3_ = 0; + return this; + } + + // optional int32 arg4 = 16; + public boolean hasArg4() { + return result.hasArg4(); + } + public int getArg4() { + return result.getArg4(); + } + public Builder setArg4(int value) { + result.hasArg4 = true; + result.arg4_ = value; + return this; + } + public Builder clearArg4() { + result.hasArg4 = false; + result.arg4_ = 0; + return this; + } + + // optional int32 arg5 = 17; + public boolean hasArg5() { + return result.hasArg5(); + } + public int getArg5() { + return result.getArg5(); + } + public Builder setArg5(int value) { + result.hasArg5 = true; + result.arg5_ = value; + return this; + } + public Builder clearArg5() { + result.hasArg5 = false; + result.arg5_ = 0; + return this; + } + + // optional int32 arg6 = 18; + public boolean hasArg6() { + return result.hasArg6(); + } + public int getArg6() { + return result.getArg6(); + } + public Builder setArg6(int value) { + result.hasArg6 = true; + result.arg6_ = value; + return this; + } + public Builder clearArg6() { + result.hasArg6 = false; + result.arg6_ = 0; + return this; + } + + // optional int32 arg7 = 19; + public boolean hasArg7() { + return result.hasArg7(); + } + public int getArg7() { + return result.getArg7(); + } + public Builder setArg7(int value) { + result.hasArg7 = true; + result.arg7_ = value; + return this; + } + public Builder clearArg7() { + result.hasArg7 = false; + result.arg7_ = 0; + return this; + } + + // optional int32 arg8 = 20; + public boolean hasArg8() { + return result.hasArg8(); + } + public int getArg8() { + return result.getArg8(); + } + public Builder setArg8(int value) { + result.hasArg8 = true; + result.arg8_ = value; + return this; + } + public Builder clearArg8() { + result.hasArg8 = false; + result.arg8_ = 0; + return this; + } + + // optional bytes data = 10; + public boolean hasData() { + return result.hasData(); + } + public com.google.protobuf.ByteString getData() { + return result.getData(); + } + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + result.hasData = true; + result.data_ = value; + return this; + } + public Builder clearData() { + result.hasData = false; + result.data_ = getDefaultInstance().getData(); + return this; + } + + // optional float time = 11; + public boolean hasTime() { + return result.hasTime(); + } + public float getTime() { + return result.getTime(); + } + public Builder setTime(float value) { + result.hasTime = true; + result.time_ = value; + return this; + } + public Builder clearTime() { + result.hasTime = false; + result.time_ = 0F; + return this; + } + + // optional .com.android.glesv2debugger.Message.Prop prop = 21; + public boolean hasProp() { + return result.hasProp(); + } + public com.android.glesv2debugger.DebuggerMessage.Message.Prop getProp() { + return result.getProp(); + } + public Builder setProp(com.android.glesv2debugger.DebuggerMessage.Message.Prop value) { + if (value == null) { + throw new NullPointerException(); + } + result.hasProp = true; + result.prop_ = value; + return this; + } + public Builder clearProp() { + result.hasProp = false; + result.prop_ = com.android.glesv2debugger.DebuggerMessage.Message.Prop.Capture; + return this; + } + + // optional float clock = 22; + public boolean hasClock() { + return result.hasClock(); + } + public float getClock() { + return result.getClock(); + } + public Builder setClock(float value) { + result.hasClock = true; + result.clock_ = value; + return this; + } + public Builder clearClock() { + result.hasClock = false; + result.clock_ = 0F; + return this; + } + + // @@protoc_insertion_point(builder_scope:com.android.glesv2debugger.Message) + } + + static { + defaultInstance = new Message(true); + com.android.glesv2debugger.DebuggerMessage.internalForceInit(); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:com.android.glesv2debugger.Message) + } + + + static { + } + + public static void internalForceInit() {} + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/GLEnum.java b/tools/glesv2debugger/src/com/android/glesv2debugger/GLEnum.java new file mode 100644 index 000000000..8fd3014b3 --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/GLEnum.java @@ -0,0 +1,632 @@ +/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_GLEnum_java.py" + +package com.android.glesv2debugger; + +public enum GLEnum { + GL_POINTS(0x0000), + GL_LINES(0x0001), + GL_LINE_LOOP(0x0002), + GL_LINE_STRIP(0x0003), + GL_TRIANGLES(0x0004), + GL_TRIANGLE_STRIP(0x0005), + GL_TRIANGLE_FAN(0x0006), + GL_ADD(0x0104), + GL_NEVER(0x0200), + GL_LESS(0x0201), + GL_EQUAL(0x0202), + GL_LEQUAL(0x0203), + GL_GREATER(0x0204), + GL_NOTEQUAL(0x0205), + GL_GEQUAL(0x0206), + GL_ALWAYS(0x0207), + GL_SRC_COLOR(0x0300), + GL_ONE_MINUS_SRC_COLOR(0x0301), + GL_SRC_ALPHA(0x0302), + GL_ONE_MINUS_SRC_ALPHA(0x0303), + GL_DST_ALPHA(0x0304), + GL_ONE_MINUS_DST_ALPHA(0x0305), + GL_DST_COLOR(0x0306), + GL_ONE_MINUS_DST_COLOR(0x0307), + GL_SRC_ALPHA_SATURATE(0x0308), + GL_FRONT(0x0404), + GL_BACK(0x0405), + GL_FRONT_AND_BACK(0x0408), + GL_INVALID_ENUM(0x0500), + GL_INVALID_VALUE(0x0501), + GL_INVALID_OPERATION(0x0502), + GL_STACK_OVERFLOW(0x0503), + GL_STACK_UNDERFLOW(0x0504), + GL_OUT_OF_MEMORY(0x0505), + GL_INVALID_FRAMEBUFFER_OPERATION_OES(0x0506), + GL_EXP(0x0800), + GL_EXP2(0x0801), + GL_CW(0x0900), + GL_CCW(0x0901), + GL_CURRENT_COLOR(0x0B00), + GL_CURRENT_NORMAL(0x0B02), + GL_CURRENT_TEXTURE_COORDS(0x0B03), + GL_POINT_SMOOTH(0x0B10), + GL_POINT_SIZE(0x0B11), + GL_SMOOTH_POINT_SIZE_RANGE(0x0B12), + GL_LINE_SMOOTH(0x0B20), + GL_LINE_WIDTH(0x0B21), + GL_SMOOTH_LINE_WIDTH_RANGE(0x0B22), + GL_CULL_FACE(0x0B44), + GL_CULL_FACE_MODE(0x0B45), + GL_FRONT_FACE(0x0B46), + GL_LIGHTING(0x0B50), + GL_LIGHT_MODEL_TWO_SIDE(0x0B52), + GL_LIGHT_MODEL_AMBIENT(0x0B53), + GL_SHADE_MODEL(0x0B54), + GL_COLOR_MATERIAL(0x0B57), + GL_FOG(0x0B60), + GL_FOG_DENSITY(0x0B62), + GL_FOG_START(0x0B63), + GL_FOG_END(0x0B64), + GL_FOG_MODE(0x0B65), + GL_FOG_COLOR(0x0B66), + GL_DEPTH_RANGE(0x0B70), + GL_DEPTH_TEST(0x0B71), + GL_DEPTH_WRITEMASK(0x0B72), + GL_DEPTH_CLEAR_VALUE(0x0B73), + GL_DEPTH_FUNC(0x0B74), + GL_STENCIL_TEST(0x0B90), + GL_STENCIL_CLEAR_VALUE(0x0B91), + GL_STENCIL_FUNC(0x0B92), + GL_STENCIL_VALUE_MASK(0x0B93), + GL_STENCIL_FAIL(0x0B94), + GL_STENCIL_PASS_DEPTH_FAIL(0x0B95), + GL_STENCIL_PASS_DEPTH_PASS(0x0B96), + GL_STENCIL_REF(0x0B97), + GL_STENCIL_WRITEMASK(0x0B98), + GL_MATRIX_MODE(0x0BA0), + GL_NORMALIZE(0x0BA1), + GL_VIEWPORT(0x0BA2), + GL_MODELVIEW_STACK_DEPTH(0x0BA3), + GL_PROJECTION_STACK_DEPTH(0x0BA4), + GL_TEXTURE_STACK_DEPTH(0x0BA5), + GL_MODELVIEW_MATRIX(0x0BA6), + GL_PROJECTION_MATRIX(0x0BA7), + GL_TEXTURE_MATRIX(0x0BA8), + GL_ALPHA_TEST(0x0BC0), + GL_ALPHA_TEST_FUNC(0x0BC1), + GL_ALPHA_TEST_REF(0x0BC2), + GL_DITHER(0x0BD0), + GL_BLEND_DST(0x0BE0), + GL_BLEND_SRC(0x0BE1), + GL_BLEND(0x0BE2), + GL_LOGIC_OP_MODE(0x0BF0), + GL_COLOR_LOGIC_OP(0x0BF2), + GL_SCISSOR_BOX(0x0C10), + GL_SCISSOR_TEST(0x0C11), + GL_COLOR_CLEAR_VALUE(0x0C22), + GL_COLOR_WRITEMASK(0x0C23), + GL_PERSPECTIVE_CORRECTION_HINT(0x0C50), + GL_POINT_SMOOTH_HINT(0x0C51), + GL_LINE_SMOOTH_HINT(0x0C52), + GL_FOG_HINT(0x0C54), + GL_UNPACK_ALIGNMENT(0x0CF5), + GL_PACK_ALIGNMENT(0x0D05), + GL_ALPHA_SCALE(0x0D1C), + GL_MAX_LIGHTS(0x0D31), + GL_MAX_CLIP_PLANES(0x0D32), + GL_MAX_TEXTURE_SIZE(0x0D33), + GL_MAX_MODELVIEW_STACK_DEPTH(0x0D36), + GL_MAX_PROJECTION_STACK_DEPTH(0x0D38), + GL_MAX_TEXTURE_STACK_DEPTH(0x0D39), + GL_MAX_VIEWPORT_DIMS(0x0D3A), + GL_SUBPIXEL_BITS(0x0D50), + GL_RED_BITS(0x0D52), + GL_GREEN_BITS(0x0D53), + GL_BLUE_BITS(0x0D54), + GL_ALPHA_BITS(0x0D55), + GL_DEPTH_BITS(0x0D56), + GL_STENCIL_BITS(0x0D57), + GL_TEXTURE_2D(0x0DE1), + GL_DONT_CARE(0x1100), + GL_FASTEST(0x1101), + GL_NICEST(0x1102), + GL_AMBIENT(0x1200), + GL_DIFFUSE(0x1201), + GL_SPECULAR(0x1202), + GL_POSITION(0x1203), + GL_SPOT_DIRECTION(0x1204), + GL_SPOT_EXPONENT(0x1205), + GL_SPOT_CUTOFF(0x1206), + GL_CONSTANT_ATTENUATION(0x1207), + GL_LINEAR_ATTENUATION(0x1208), + GL_QUADRATIC_ATTENUATION(0x1209), + GL_BYTE(0x1400), + GL_UNSIGNED_BYTE(0x1401), + GL_SHORT(0x1402), + GL_UNSIGNED_SHORT(0x1403), + GL_INT(0x1404), + GL_UNSIGNED_INT(0x1405), + GL_FLOAT(0x1406), + GL_FIXED(0x140C), + GL_CLEAR(0x1500), + GL_AND(0x1501), + GL_AND_REVERSE(0x1502), + GL_COPY(0x1503), + GL_AND_INVERTED(0x1504), + GL_NOOP(0x1505), + GL_XOR(0x1506), + GL_OR(0x1507), + GL_NOR(0x1508), + GL_EQUIV(0x1509), + GL_INVERT(0x150A), + GL_OR_REVERSE(0x150B), + GL_COPY_INVERTED(0x150C), + GL_OR_INVERTED(0x150D), + GL_NAND(0x150E), + GL_SET(0x150F), + GL_EMISSION(0x1600), + GL_SHININESS(0x1601), + GL_AMBIENT_AND_DIFFUSE(0x1602), + GL_MODELVIEW(0x1700), + GL_PROJECTION(0x1701), + GL_TEXTURE(0x1702), + GL_COLOR_EXT(0x1800), + GL_DEPTH_EXT(0x1801), + GL_STENCIL_EXT(0x1802), + GL_STENCIL_INDEX(0x1901), + GL_DEPTH_COMPONENT(0x1902), + GL_ALPHA(0x1906), + GL_RGB(0x1907), + GL_RGBA(0x1908), + GL_LUMINANCE(0x1909), + GL_LUMINANCE_ALPHA(0x190A), + GL_FLAT(0x1D00), + GL_SMOOTH(0x1D01), + GL_KEEP(0x1E00), + GL_REPLACE(0x1E01), + GL_INCR(0x1E02), + GL_DECR(0x1E03), + GL_VENDOR(0x1F00), + GL_RENDERER(0x1F01), + GL_VERSION(0x1F02), + GL_EXTENSIONS(0x1F03), + GL_MODULATE(0x2100), + GL_DECAL(0x2101), + GL_TEXTURE_ENV_MODE(0x2200), + GL_TEXTURE_ENV_COLOR(0x2201), + GL_TEXTURE_ENV(0x2300), + GL_TEXTURE_GEN_MODE_OES(0x2500), + GL_NEAREST(0x2600), + GL_LINEAR(0x2601), + GL_NEAREST_MIPMAP_NEAREST(0x2700), + GL_LINEAR_MIPMAP_NEAREST(0x2701), + GL_NEAREST_MIPMAP_LINEAR(0x2702), + GL_LINEAR_MIPMAP_LINEAR(0x2703), + GL_TEXTURE_MAG_FILTER(0x2800), + GL_TEXTURE_MIN_FILTER(0x2801), + GL_TEXTURE_WRAP_S(0x2802), + GL_TEXTURE_WRAP_T(0x2803), + GL_REPEAT(0x2901), + GL_POLYGON_OFFSET_UNITS(0x2A00), + GL_CLIP_PLANE0(0x3000), + GL_CLIP_PLANE1(0x3001), + GL_CLIP_PLANE2(0x3002), + GL_CLIP_PLANE3(0x3003), + GL_CLIP_PLANE4(0x3004), + GL_CLIP_PLANE5(0x3005), + GL_LIGHT0(0x4000), + GL_LIGHT1(0x4001), + GL_LIGHT2(0x4002), + GL_LIGHT3(0x4003), + GL_LIGHT4(0x4004), + GL_LIGHT5(0x4005), + GL_LIGHT6(0x4006), + GL_LIGHT7(0x4007), + GL_COVERAGE_BUFFER_BIT_NV(0x8000), + GL_CONSTANT_COLOR(0x8001), + GL_ONE_MINUS_CONSTANT_COLOR(0x8002), + GL_CONSTANT_ALPHA(0x8003), + GL_ONE_MINUS_CONSTANT_ALPHA(0x8004), + GL_BLEND_COLOR(0x8005), + GL_FUNC_ADD_OES(0x8006), + GL_MIN_EXT(0x8007), + GL_MAX_EXT(0x8008), + GL_BLEND_EQUATION_RGB_OES(0x8009), + GL_FUNC_SUBTRACT_OES(0x800A), + GL_FUNC_REVERSE_SUBTRACT_OES(0x800B), + GL_UNSIGNED_SHORT_4_4_4_4(0x8033), + GL_UNSIGNED_SHORT_5_5_5_1(0x8034), + GL_POLYGON_OFFSET_FILL(0x8037), + GL_POLYGON_OFFSET_FACTOR(0x8038), + GL_RESCALE_NORMAL(0x803A), + GL_RGB8_OES(0x8051), + GL_RGBA4_OES(0x8056), + GL_RGB5_A1_OES(0x8057), + GL_RGBA8_OES(0x8058), + GL_TEXTURE_BINDING_2D(0x8069), + GL_TEXTURE_BINDING_3D_OES(0x806A), + GL_TEXTURE_3D_OES(0x806F), + GL_TEXTURE_WRAP_R_OES(0x8072), + GL_MAX_3D_TEXTURE_SIZE_OES(0x8073), + GL_VERTEX_ARRAY(0x8074), + GL_NORMAL_ARRAY(0x8075), + GL_COLOR_ARRAY(0x8076), + GL_TEXTURE_COORD_ARRAY(0x8078), + GL_VERTEX_ARRAY_SIZE(0x807A), + GL_VERTEX_ARRAY_TYPE(0x807B), + GL_VERTEX_ARRAY_STRIDE(0x807C), + GL_NORMAL_ARRAY_TYPE(0x807E), + GL_NORMAL_ARRAY_STRIDE(0x807F), + GL_COLOR_ARRAY_SIZE(0x8081), + GL_COLOR_ARRAY_TYPE(0x8082), + GL_COLOR_ARRAY_STRIDE(0x8083), + GL_TEXTURE_COORD_ARRAY_SIZE(0x8088), + GL_TEXTURE_COORD_ARRAY_TYPE(0x8089), + GL_TEXTURE_COORD_ARRAY_STRIDE(0x808A), + GL_VERTEX_ARRAY_POINTER(0x808E), + GL_NORMAL_ARRAY_POINTER(0x808F), + GL_COLOR_ARRAY_POINTER(0x8090), + GL_TEXTURE_COORD_ARRAY_POINTER(0x8092), + GL_MULTISAMPLE(0x809D), + GL_SAMPLE_ALPHA_TO_COVERAGE(0x809E), + GL_SAMPLE_ALPHA_TO_ONE(0x809F), + GL_SAMPLE_COVERAGE(0x80A0), + GL_SAMPLE_BUFFERS(0x80A8), + GL_SAMPLES(0x80A9), + GL_SAMPLE_COVERAGE_VALUE(0x80AA), + GL_SAMPLE_COVERAGE_INVERT(0x80AB), + GL_BLEND_DST_RGB_OES(0x80C8), + GL_BLEND_SRC_RGB_OES(0x80C9), + GL_BLEND_DST_ALPHA_OES(0x80CA), + GL_BLEND_SRC_ALPHA_OES(0x80CB), + GL_BGRA_EXT(0x80E1), + GL_POINT_SIZE_MIN(0x8126), + GL_POINT_SIZE_MAX(0x8127), + GL_POINT_FADE_THRESHOLD_SIZE(0x8128), + GL_POINT_DISTANCE_ATTENUATION(0x8129), + GL_CLAMP_TO_EDGE(0x812F), + GL_GENERATE_MIPMAP(0x8191), + GL_GENERATE_MIPMAP_HINT(0x8192), + GL_DEPTH_COMPONENT16_OES(0x81A5), + GL_DEPTH_COMPONENT24_OES(0x81A6), + GL_DEPTH_COMPONENT32_OES(0x81A7), + GL_UNSIGNED_SHORT_5_6_5(0x8363), + GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT(0x8365), + GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT(0x8366), + GL_UNSIGNED_INT_2_10_10_10_REV_EXT(0x8368), + GL_MIRRORED_REPEAT_OES(0x8370), + GL_COMPRESSED_RGB_S3TC_DXT1_EXT(0x83F0), + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT(0x83F1), + GL_ALIASED_POINT_SIZE_RANGE(0x846D), + GL_ALIASED_LINE_WIDTH_RANGE(0x846E), + GL_TEXTURE0(0x84C0), + GL_TEXTURE1(0x84C1), + GL_TEXTURE2(0x84C2), + GL_TEXTURE3(0x84C3), + GL_TEXTURE4(0x84C4), + GL_TEXTURE5(0x84C5), + GL_TEXTURE6(0x84C6), + GL_TEXTURE7(0x84C7), + GL_TEXTURE8(0x84C8), + GL_TEXTURE9(0x84C9), + GL_TEXTURE10(0x84CA), + GL_TEXTURE11(0x84CB), + GL_TEXTURE12(0x84CC), + GL_TEXTURE13(0x84CD), + GL_TEXTURE14(0x84CE), + GL_TEXTURE15(0x84CF), + GL_TEXTURE16(0x84D0), + GL_TEXTURE17(0x84D1), + GL_TEXTURE18(0x84D2), + GL_TEXTURE19(0x84D3), + GL_TEXTURE20(0x84D4), + GL_TEXTURE21(0x84D5), + GL_TEXTURE22(0x84D6), + GL_TEXTURE23(0x84D7), + GL_TEXTURE24(0x84D8), + GL_TEXTURE25(0x84D9), + GL_TEXTURE26(0x84DA), + GL_TEXTURE27(0x84DB), + GL_TEXTURE28(0x84DC), + GL_TEXTURE29(0x84DD), + GL_TEXTURE30(0x84DE), + GL_TEXTURE31(0x84DF), + GL_ACTIVE_TEXTURE(0x84E0), + GL_CLIENT_ACTIVE_TEXTURE(0x84E1), + GL_MAX_TEXTURE_UNITS(0x84E2), + GL_SUBTRACT(0x84E7), + GL_MAX_RENDERBUFFER_SIZE_OES(0x84E8), + GL_ALL_COMPLETED_NV(0x84F2), + GL_FENCE_STATUS_NV(0x84F3), + GL_FENCE_CONDITION_NV(0x84F4), + GL_DEPTH_STENCIL_OES(0x84F9), + GL_UNSIGNED_INT_24_8_OES(0x84FA), + GL_MAX_TEXTURE_LOD_BIAS_EXT(0x84FD), + GL_TEXTURE_MAX_ANISOTROPY_EXT(0x84FE), + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT(0x84FF), + GL_TEXTURE_FILTER_CONTROL_EXT(0x8500), + GL_TEXTURE_LOD_BIAS_EXT(0x8501), + GL_INCR_WRAP_OES(0x8507), + GL_DECR_WRAP_OES(0x8508), + GL_NORMAL_MAP_OES(0x8511), + GL_REFLECTION_MAP_OES(0x8512), + GL_TEXTURE_CUBE_MAP_OES(0x8513), + GL_TEXTURE_BINDING_CUBE_MAP_OES(0x8514), + GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES(0x8515), + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES(0x8516), + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES(0x8517), + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES(0x8518), + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES(0x8519), + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES(0x851A), + GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES(0x851C), + GL_COMBINE(0x8570), + GL_COMBINE_RGB(0x8571), + GL_COMBINE_ALPHA(0x8572), + GL_RGB_SCALE(0x8573), + GL_ADD_SIGNED(0x8574), + GL_INTERPOLATE(0x8575), + GL_CONSTANT(0x8576), + GL_PRIMARY_COLOR(0x8577), + GL_PREVIOUS(0x8578), + GL_SRC0_RGB(0x8580), + GL_SRC1_RGB(0x8581), + GL_SRC2_RGB(0x8582), + GL_SRC0_ALPHA(0x8588), + GL_SRC1_ALPHA(0x8589), + GL_SRC2_ALPHA(0x858A), + GL_OPERAND0_RGB(0x8590), + GL_OPERAND1_RGB(0x8591), + GL_OPERAND2_RGB(0x8592), + GL_OPERAND0_ALPHA(0x8598), + GL_OPERAND1_ALPHA(0x8599), + GL_OPERAND2_ALPHA(0x859A), + GL_VERTEX_ARRAY_BINDING_OES(0x85B5), + GL_VERTEX_ATTRIB_ARRAY_ENABLED(0x8622), + GL_VERTEX_ATTRIB_ARRAY_SIZE(0x8623), + GL_VERTEX_ATTRIB_ARRAY_STRIDE(0x8624), + GL_VERTEX_ATTRIB_ARRAY_TYPE(0x8625), + GL_CURRENT_VERTEX_ATTRIB(0x8626), + GL_VERTEX_ATTRIB_ARRAY_POINTER(0x8645), + GL_NUM_COMPRESSED_TEXTURE_FORMATS(0x86A2), + GL_COMPRESSED_TEXTURE_FORMATS(0x86A3), + GL_MAX_VERTEX_UNITS_OES(0x86A4), + GL_WEIGHT_ARRAY_TYPE_OES(0x86A9), + GL_WEIGHT_ARRAY_STRIDE_OES(0x86AA), + GL_WEIGHT_ARRAY_SIZE_OES(0x86AB), + GL_WEIGHT_ARRAY_POINTER_OES(0x86AC), + GL_WEIGHT_ARRAY_OES(0x86AD), + GL_DOT3_RGB(0x86AE), + GL_DOT3_RGBA(0x86AF), + GL_Z400_BINARY_AMD(0x8740), + GL_PROGRAM_BINARY_LENGTH_OES(0x8741), + GL_BUFFER_SIZE(0x8764), + GL_BUFFER_USAGE(0x8765), + GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD(0x87EE), + GL_3DC_X_AMD(0x87F9), + GL_3DC_XY_AMD(0x87FA), + GL_NUM_PROGRAM_BINARY_FORMATS_OES(0x87FE), + GL_PROGRAM_BINARY_FORMATS_OES(0x87FF), + GL_STENCIL_BACK_FUNC(0x8800), + GL_STENCIL_BACK_FAIL(0x8801), + GL_STENCIL_BACK_PASS_DEPTH_FAIL(0x8802), + GL_STENCIL_BACK_PASS_DEPTH_PASS(0x8803), + GL_WRITEONLY_RENDERING_QCOM(0x8823), + GL_BLEND_EQUATION_ALPHA_OES(0x883D), + GL_MATRIX_PALETTE_OES(0x8840), + GL_MAX_PALETTE_MATRICES_OES(0x8842), + GL_CURRENT_PALETTE_MATRIX_OES(0x8843), + GL_MATRIX_INDEX_ARRAY_OES(0x8844), + GL_MATRIX_INDEX_ARRAY_SIZE_OES(0x8846), + GL_MATRIX_INDEX_ARRAY_TYPE_OES(0x8847), + GL_MATRIX_INDEX_ARRAY_STRIDE_OES(0x8848), + GL_MATRIX_INDEX_ARRAY_POINTER_OES(0x8849), + GL_POINT_SPRITE_OES(0x8861), + GL_COORD_REPLACE_OES(0x8862), + GL_MAX_VERTEX_ATTRIBS(0x8869), + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED(0x886A), + GL_MAX_TEXTURE_IMAGE_UNITS(0x8872), + GL_ARRAY_BUFFER(0x8892), + GL_ELEMENT_ARRAY_BUFFER(0x8893), + GL_ARRAY_BUFFER_BINDING(0x8894), + GL_ELEMENT_ARRAY_BUFFER_BINDING(0x8895), + GL_VERTEX_ARRAY_BUFFER_BINDING(0x8896), + GL_NORMAL_ARRAY_BUFFER_BINDING(0x8897), + GL_COLOR_ARRAY_BUFFER_BINDING(0x8898), + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING(0x889A), + GL_WEIGHT_ARRAY_BUFFER_BINDING_OES(0x889E), + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING(0x889F), + GL_WRITE_ONLY_OES(0x88B9), + GL_BUFFER_ACCESS_OES(0x88BB), + GL_BUFFER_MAPPED_OES(0x88BC), + GL_BUFFER_MAP_POINTER_OES(0x88BD), + GL_STREAM_DRAW(0x88E0), + GL_STATIC_DRAW(0x88E4), + GL_DYNAMIC_DRAW(0x88E8), + GL_DEPTH24_STENCIL8_OES(0x88F0), + GL_POINT_SIZE_ARRAY_TYPE_OES(0x898A), + GL_POINT_SIZE_ARRAY_STRIDE_OES(0x898B), + GL_POINT_SIZE_ARRAY_POINTER_OES(0x898C), + GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES(0x898D), + GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES(0x898E), + GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES(0x898F), + GL_FRAGMENT_SHADER(0x8B30), + GL_VERTEX_SHADER(0x8B31), + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS(0x8B4C), + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS(0x8B4D), + GL_SHADER_TYPE(0x8B4F), + GL_FLOAT_VEC2(0x8B50), + GL_FLOAT_VEC3(0x8B51), + GL_FLOAT_VEC4(0x8B52), + GL_INT_VEC2(0x8B53), + GL_INT_VEC3(0x8B54), + GL_INT_VEC4(0x8B55), + GL_BOOL(0x8B56), + GL_BOOL_VEC2(0x8B57), + GL_BOOL_VEC3(0x8B58), + GL_BOOL_VEC4(0x8B59), + GL_FLOAT_MAT2(0x8B5A), + GL_FLOAT_MAT3(0x8B5B), + GL_FLOAT_MAT4(0x8B5C), + GL_SAMPLER_2D(0x8B5E), + GL_SAMPLER_3D_OES(0x8B5F), + GL_SAMPLER_CUBE(0x8B60), + GL_DELETE_STATUS(0x8B80), + GL_COMPILE_STATUS(0x8B81), + GL_LINK_STATUS(0x8B82), + GL_VALIDATE_STATUS(0x8B83), + GL_INFO_LOG_LENGTH(0x8B84), + GL_ATTACHED_SHADERS(0x8B85), + GL_ACTIVE_UNIFORMS(0x8B86), + GL_ACTIVE_UNIFORM_MAX_LENGTH(0x8B87), + GL_SHADER_SOURCE_LENGTH(0x8B88), + GL_ACTIVE_ATTRIBUTES(0x8B89), + GL_ACTIVE_ATTRIBUTE_MAX_LENGTH(0x8B8A), + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES(0x8B8B), + GL_SHADING_LANGUAGE_VERSION(0x8B8C), + GL_CURRENT_PROGRAM(0x8B8D), + GL_PALETTE4_RGB8_OES(0x8B90), + GL_PALETTE4_RGBA8_OES(0x8B91), + GL_PALETTE4_R5_G6_B5_OES(0x8B92), + GL_PALETTE4_RGBA4_OES(0x8B93), + GL_PALETTE4_RGB5_A1_OES(0x8B94), + GL_PALETTE8_RGB8_OES(0x8B95), + GL_PALETTE8_RGBA8_OES(0x8B96), + GL_PALETTE8_R5_G6_B5_OES(0x8B97), + GL_PALETTE8_RGBA4_OES(0x8B98), + GL_PALETTE8_RGB5_A1_OES(0x8B99), + GL_IMPLEMENTATION_COLOR_READ_TYPE_OES(0x8B9A), + GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES(0x8B9B), + GL_POINT_SIZE_ARRAY_OES(0x8B9C), + GL_TEXTURE_CROP_RECT_OES(0x8B9D), + GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES(0x8B9E), + GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES(0x8B9F), + GL_COUNTER_TYPE_AMD(0x8BC0), + GL_COUNTER_RANGE_AMD(0x8BC1), + GL_UNSIGNED_INT64_AMD(0x8BC2), + GL_PERCENTAGE_AMD(0x8BC3), + GL_PERFMON_RESULT_AVAILABLE_AMD(0x8BC4), + GL_PERFMON_RESULT_SIZE_AMD(0x8BC5), + GL_PERFMON_RESULT_AMD(0x8BC6), + GL_TEXTURE_WIDTH_QCOM(0x8BD2), + GL_TEXTURE_HEIGHT_QCOM(0x8BD3), + GL_TEXTURE_DEPTH_QCOM(0x8BD4), + GL_TEXTURE_INTERNAL_FORMAT_QCOM(0x8BD5), + GL_TEXTURE_FORMAT_QCOM(0x8BD6), + GL_TEXTURE_TYPE_QCOM(0x8BD7), + GL_TEXTURE_IMAGE_VALID_QCOM(0x8BD8), + GL_TEXTURE_NUM_LEVELS_QCOM(0x8BD9), + GL_TEXTURE_TARGET_QCOM(0x8BDA), + GL_TEXTURE_OBJECT_VALID_QCOM(0x8BDB), + GL_STATE_RESTORE(0x8BDC), + GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG(0x8C00), + GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG(0x8C01), + GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG(0x8C02), + GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG(0x8C03), + GL_MODULATE_COLOR_IMG(0x8C04), + GL_RECIP_ADD_SIGNED_ALPHA_IMG(0x8C05), + GL_TEXTURE_ALPHA_MODULATE_IMG(0x8C06), + GL_FACTOR_ALPHA_MODULATE_IMG(0x8C07), + GL_FRAGMENT_ALPHA_MODULATE_IMG(0x8C08), + GL_ADD_BLEND_IMG(0x8C09), + GL_SGX_BINARY_IMG(0x8C0A), + GL_ATC_RGB_AMD(0x8C92), + GL_ATC_RGBA_EXPLICIT_ALPHA_AMD(0x8C93), + GL_STENCIL_BACK_REF(0x8CA3), + GL_STENCIL_BACK_VALUE_MASK(0x8CA4), + GL_STENCIL_BACK_WRITEMASK(0x8CA5), + GL_FRAMEBUFFER_BINDING_OES(0x8CA6), + GL_RENDERBUFFER_BINDING_OES(0x8CA7), + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES(0x8CD0), + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES(0x8CD1), + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES(0x8CD2), + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES(0x8CD3), + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES(0x8CD4), + GL_FRAMEBUFFER_COMPLETE_OES(0x8CD5), + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES(0x8CD6), + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES(0x8CD7), + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES(0x8CD9), + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES(0x8CDA), + GL_FRAMEBUFFER_UNSUPPORTED_OES(0x8CDD), + GL_COLOR_ATTACHMENT0_OES(0x8CE0), + GL_DEPTH_ATTACHMENT_OES(0x8D00), + GL_STENCIL_ATTACHMENT_OES(0x8D20), + GL_FRAMEBUFFER_OES(0x8D40), + GL_RENDERBUFFER_OES(0x8D41), + GL_RENDERBUFFER_WIDTH_OES(0x8D42), + GL_RENDERBUFFER_HEIGHT_OES(0x8D43), + GL_RENDERBUFFER_INTERNAL_FORMAT_OES(0x8D44), + GL_STENCIL_INDEX1_OES(0x8D46), + GL_STENCIL_INDEX4_OES(0x8D47), + GL_STENCIL_INDEX8_OES(0x8D48), + GL_RENDERBUFFER_RED_SIZE_OES(0x8D50), + GL_RENDERBUFFER_GREEN_SIZE_OES(0x8D51), + GL_RENDERBUFFER_BLUE_SIZE_OES(0x8D52), + GL_RENDERBUFFER_ALPHA_SIZE_OES(0x8D53), + GL_RENDERBUFFER_DEPTH_SIZE_OES(0x8D54), + GL_RENDERBUFFER_STENCIL_SIZE_OES(0x8D55), + GL_TEXTURE_GEN_STR_OES(0x8D60), + GL_HALF_FLOAT_OES(0x8D61), + GL_RGB565_OES(0x8D62), + GL_ETC1_RGB8_OES(0x8D64), + GL_TEXTURE_EXTERNAL_OES(0x8D65), + GL_SAMPLER_EXTERNAL_OES(0x8D66), + GL_TEXTURE_BINDING_EXTERNAL_OES(0x8D67), + GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES(0x8D68), + GL_LOW_FLOAT(0x8DF0), + GL_MEDIUM_FLOAT(0x8DF1), + GL_HIGH_FLOAT(0x8DF2), + GL_LOW_INT(0x8DF3), + GL_MEDIUM_INT(0x8DF4), + GL_HIGH_INT(0x8DF5), + GL_UNSIGNED_INT_10_10_10_2_OES(0x8DF6), + GL_INT_10_10_10_2_OES(0x8DF7), + GL_SHADER_BINARY_FORMATS(0x8DF8), + GL_NUM_SHADER_BINARY_FORMATS(0x8DF9), + GL_SHADER_COMPILER(0x8DFA), + GL_MAX_VERTEX_UNIFORM_VECTORS(0x8DFB), + GL_MAX_VARYING_VECTORS(0x8DFC), + GL_MAX_FRAGMENT_UNIFORM_VECTORS(0x8DFD), + GL_DEPTH_COMPONENT16_NONLINEAR_NV(0x8E2C), + GL_COVERAGE_COMPONENT_NV(0x8ED0), + GL_COVERAGE_COMPONENT4_NV(0x8ED1), + GL_COVERAGE_ATTACHMENT_NV(0x8ED2), + GL_COVERAGE_BUFFERS_NV(0x8ED3), + GL_COVERAGE_SAMPLES_NV(0x8ED4), + GL_COVERAGE_ALL_FRAGMENTS_NV(0x8ED5), + GL_COVERAGE_EDGE_FRAGMENTS_NV(0x8ED6), + GL_COVERAGE_AUTOMATIC_NV(0x8ED7), + GL_PERFMON_GLOBAL_MODE_QCOM(0x8FA0), + GL_SGX_PROGRAM_BINARY_IMG(0x9130), + GL_RENDERBUFFER_SAMPLES_IMG(0x9133), + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG(0x9134), + GL_MAX_SAMPLES_IMG(0x9135), + GL_TEXTURE_SAMPLES_IMG(0x9136), + ; + + public final int value; + GLEnum(final int value) { + this.value = value; + } + + private static final java.util.HashMap reverseMap = new java.util.HashMap(); + static { + for (GLEnum e : GLEnum.values()) + reverseMap.put(e.value, e); + } + + public static GLEnum valueOf(final int value) { + return reverseMap.get(value); + } +} \ No newline at end of file diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/GLFunction.java b/tools/glesv2debugger/src/com/android/glesv2debugger/GLFunction.java new file mode 100644 index 000000000..081f1b2bc --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/GLFunction.java @@ -0,0 +1,173 @@ +/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_GLFunction_java.py" + +package com.android.glesv2debugger; + +public enum GLFunction { + glActiveTexture(0, DebuggerMessage.Message.Function.glActiveTexture), + glAttachShader(1, DebuggerMessage.Message.Function.glAttachShader), + glBindAttribLocation(2, DebuggerMessage.Message.Function.glBindAttribLocation), + glBindBuffer(3, DebuggerMessage.Message.Function.glBindBuffer), + glBindFramebuffer(4, DebuggerMessage.Message.Function.glBindFramebuffer), + glBindRenderbuffer(5, DebuggerMessage.Message.Function.glBindRenderbuffer), + glBindTexture(6, DebuggerMessage.Message.Function.glBindTexture), + glBlendColor(7, DebuggerMessage.Message.Function.glBlendColor), + glBlendEquation(8, DebuggerMessage.Message.Function.glBlendEquation), + glBlendEquationSeparate(9, DebuggerMessage.Message.Function.glBlendEquationSeparate), + glBlendFunc(10, DebuggerMessage.Message.Function.glBlendFunc), + glBlendFuncSeparate(11, DebuggerMessage.Message.Function.glBlendFuncSeparate), + glBufferData(12, DebuggerMessage.Message.Function.glBufferData), + glBufferSubData(13, DebuggerMessage.Message.Function.glBufferSubData), + glCheckFramebufferStatus(14, DebuggerMessage.Message.Function.glCheckFramebufferStatus), + glClear(15, DebuggerMessage.Message.Function.glClear), + glClearColor(16, DebuggerMessage.Message.Function.glClearColor), + glClearDepthf(17, DebuggerMessage.Message.Function.glClearDepthf), + glClearStencil(18, DebuggerMessage.Message.Function.glClearStencil), + glColorMask(19, DebuggerMessage.Message.Function.glColorMask), + glCompileShader(20, DebuggerMessage.Message.Function.glCompileShader), + glCompressedTexImage2D(21, DebuggerMessage.Message.Function.glCompressedTexImage2D), + glCompressedTexSubImage2D(22, DebuggerMessage.Message.Function.glCompressedTexSubImage2D), + glCopyTexImage2D(23, DebuggerMessage.Message.Function.glCopyTexImage2D), + glCopyTexSubImage2D(24, DebuggerMessage.Message.Function.glCopyTexSubImage2D), + glCreateProgram(25, DebuggerMessage.Message.Function.glCreateProgram), + glCreateShader(26, DebuggerMessage.Message.Function.glCreateShader), + glCullFace(27, DebuggerMessage.Message.Function.glCullFace), + glDeleteBuffers(28, DebuggerMessage.Message.Function.glDeleteBuffers), + glDeleteFramebuffers(29, DebuggerMessage.Message.Function.glDeleteFramebuffers), + glDeleteProgram(30, DebuggerMessage.Message.Function.glDeleteProgram), + glDeleteRenderbuffers(31, DebuggerMessage.Message.Function.glDeleteRenderbuffers), + glDeleteShader(32, DebuggerMessage.Message.Function.glDeleteShader), + glDeleteTextures(33, DebuggerMessage.Message.Function.glDeleteTextures), + glDepthFunc(34, DebuggerMessage.Message.Function.glDepthFunc), + glDepthMask(35, DebuggerMessage.Message.Function.glDepthMask), + glDepthRangef(36, DebuggerMessage.Message.Function.glDepthRangef), + glDetachShader(37, DebuggerMessage.Message.Function.glDetachShader), + glDisable(38, DebuggerMessage.Message.Function.glDisable), + glDisableVertexAttribArray(39, DebuggerMessage.Message.Function.glDisableVertexAttribArray), + glDrawArrays(40, DebuggerMessage.Message.Function.glDrawArrays), + glDrawElements(41, DebuggerMessage.Message.Function.glDrawElements), + glEnable(42, DebuggerMessage.Message.Function.glEnable), + glEnableVertexAttribArray(43, DebuggerMessage.Message.Function.glEnableVertexAttribArray), + glFinish(44, DebuggerMessage.Message.Function.glFinish), + glFlush(45, DebuggerMessage.Message.Function.glFlush), + glFramebufferRenderbuffer(46, DebuggerMessage.Message.Function.glFramebufferRenderbuffer), + glFramebufferTexture2D(47, DebuggerMessage.Message.Function.glFramebufferTexture2D), + glFrontFace(48, DebuggerMessage.Message.Function.glFrontFace), + glGenBuffers(49, DebuggerMessage.Message.Function.glGenBuffers), + glGenerateMipmap(50, DebuggerMessage.Message.Function.glGenerateMipmap), + glGenFramebuffers(51, DebuggerMessage.Message.Function.glGenFramebuffers), + glGenRenderbuffers(52, DebuggerMessage.Message.Function.glGenRenderbuffers), + glGenTextures(53, DebuggerMessage.Message.Function.glGenTextures), + glGetActiveAttrib(54, DebuggerMessage.Message.Function.glGetActiveAttrib), + glGetActiveUniform(55, DebuggerMessage.Message.Function.glGetActiveUniform), + glGetAttachedShaders(56, DebuggerMessage.Message.Function.glGetAttachedShaders), + glGetAttribLocation(57, DebuggerMessage.Message.Function.glGetAttribLocation), + glGetBooleanv(58, DebuggerMessage.Message.Function.glGetBooleanv), + glGetBufferParameteriv(59, DebuggerMessage.Message.Function.glGetBufferParameteriv), + glGetError(60, DebuggerMessage.Message.Function.glGetError), + glGetFloatv(61, DebuggerMessage.Message.Function.glGetFloatv), + glGetFramebufferAttachmentParameteriv(62, DebuggerMessage.Message.Function.glGetFramebufferAttachmentParameteriv), + glGetIntegerv(63, DebuggerMessage.Message.Function.glGetIntegerv), + glGetProgramiv(64, DebuggerMessage.Message.Function.glGetProgramiv), + glGetProgramInfoLog(65, DebuggerMessage.Message.Function.glGetProgramInfoLog), + glGetRenderbufferParameteriv(66, DebuggerMessage.Message.Function.glGetRenderbufferParameteriv), + glGetShaderiv(67, DebuggerMessage.Message.Function.glGetShaderiv), + glGetShaderInfoLog(68, DebuggerMessage.Message.Function.glGetShaderInfoLog), + glGetShaderPrecisionFormat(69, DebuggerMessage.Message.Function.glGetShaderPrecisionFormat), + glGetShaderSource(70, DebuggerMessage.Message.Function.glGetShaderSource), + glGetString(71, DebuggerMessage.Message.Function.glGetString), + glGetTexParameterfv(72, DebuggerMessage.Message.Function.glGetTexParameterfv), + glGetTexParameteriv(73, DebuggerMessage.Message.Function.glGetTexParameteriv), + glGetUniformfv(74, DebuggerMessage.Message.Function.glGetUniformfv), + glGetUniformiv(75, DebuggerMessage.Message.Function.glGetUniformiv), + glGetUniformLocation(76, DebuggerMessage.Message.Function.glGetUniformLocation), + glGetVertexAttribfv(77, DebuggerMessage.Message.Function.glGetVertexAttribfv), + glGetVertexAttribiv(78, DebuggerMessage.Message.Function.glGetVertexAttribiv), + glGetVertexAttribPointerv(79, DebuggerMessage.Message.Function.glGetVertexAttribPointerv), + glHint(80, DebuggerMessage.Message.Function.glHint), + glIsBuffer(81, DebuggerMessage.Message.Function.glIsBuffer), + glIsEnabled(82, DebuggerMessage.Message.Function.glIsEnabled), + glIsFramebuffer(83, DebuggerMessage.Message.Function.glIsFramebuffer), + glIsProgram(84, DebuggerMessage.Message.Function.glIsProgram), + glIsRenderbuffer(85, DebuggerMessage.Message.Function.glIsRenderbuffer), + glIsShader(86, DebuggerMessage.Message.Function.glIsShader), + glIsTexture(87, DebuggerMessage.Message.Function.glIsTexture), + glLineWidth(88, DebuggerMessage.Message.Function.glLineWidth), + glLinkProgram(89, DebuggerMessage.Message.Function.glLinkProgram), + glPixelStorei(90, DebuggerMessage.Message.Function.glPixelStorei), + glPolygonOffset(91, DebuggerMessage.Message.Function.glPolygonOffset), + glReadPixels(92, DebuggerMessage.Message.Function.glReadPixels), + glReleaseShaderCompiler(93, DebuggerMessage.Message.Function.glReleaseShaderCompiler), + glRenderbufferStorage(94, DebuggerMessage.Message.Function.glRenderbufferStorage), + glSampleCoverage(95, DebuggerMessage.Message.Function.glSampleCoverage), + glScissor(96, DebuggerMessage.Message.Function.glScissor), + glShaderBinary(97, DebuggerMessage.Message.Function.glShaderBinary), + glShaderSource(98, DebuggerMessage.Message.Function.glShaderSource), + glStencilFunc(99, DebuggerMessage.Message.Function.glStencilFunc), + glStencilFuncSeparate(100, DebuggerMessage.Message.Function.glStencilFuncSeparate), + glStencilMask(101, DebuggerMessage.Message.Function.glStencilMask), + glStencilMaskSeparate(102, DebuggerMessage.Message.Function.glStencilMaskSeparate), + glStencilOp(103, DebuggerMessage.Message.Function.glStencilOp), + glStencilOpSeparate(104, DebuggerMessage.Message.Function.glStencilOpSeparate), + glTexImage2D(105, DebuggerMessage.Message.Function.glTexImage2D), + glTexParameterf(106, DebuggerMessage.Message.Function.glTexParameterf), + glTexParameterfv(107, DebuggerMessage.Message.Function.glTexParameterfv), + glTexParameteri(108, DebuggerMessage.Message.Function.glTexParameteri), + glTexParameteriv(109, DebuggerMessage.Message.Function.glTexParameteriv), + glTexSubImage2D(110, DebuggerMessage.Message.Function.glTexSubImage2D), + glUniform1f(111, DebuggerMessage.Message.Function.glUniform1f), + glUniform1fv(112, DebuggerMessage.Message.Function.glUniform1fv), + glUniform1i(113, DebuggerMessage.Message.Function.glUniform1i), + glUniform1iv(114, DebuggerMessage.Message.Function.glUniform1iv), + glUniform2f(115, DebuggerMessage.Message.Function.glUniform2f), + glUniform2fv(116, DebuggerMessage.Message.Function.glUniform2fv), + glUniform2i(117, DebuggerMessage.Message.Function.glUniform2i), + glUniform2iv(118, DebuggerMessage.Message.Function.glUniform2iv), + glUniform3f(119, DebuggerMessage.Message.Function.glUniform3f), + glUniform3fv(120, DebuggerMessage.Message.Function.glUniform3fv), + glUniform3i(121, DebuggerMessage.Message.Function.glUniform3i), + glUniform3iv(122, DebuggerMessage.Message.Function.glUniform3iv), + glUniform4f(123, DebuggerMessage.Message.Function.glUniform4f), + glUniform4fv(124, DebuggerMessage.Message.Function.glUniform4fv), + glUniform4i(125, DebuggerMessage.Message.Function.glUniform4i), + glUniform4iv(126, DebuggerMessage.Message.Function.glUniform4iv), + glUniformMatrix2fv(127, DebuggerMessage.Message.Function.glUniformMatrix2fv), + glUniformMatrix3fv(128, DebuggerMessage.Message.Function.glUniformMatrix3fv), + glUniformMatrix4fv(129, DebuggerMessage.Message.Function.glUniformMatrix4fv), + glUseProgram(130, DebuggerMessage.Message.Function.glUseProgram), + glValidateProgram(131, DebuggerMessage.Message.Function.glValidateProgram), + glVertexAttrib1f(132, DebuggerMessage.Message.Function.glVertexAttrib1f), + glVertexAttrib1fv(133, DebuggerMessage.Message.Function.glVertexAttrib1fv), + glVertexAttrib2f(134, DebuggerMessage.Message.Function.glVertexAttrib2f), + glVertexAttrib2fv(135, DebuggerMessage.Message.Function.glVertexAttrib2fv), + glVertexAttrib3f(136, DebuggerMessage.Message.Function.glVertexAttrib3f), + glVertexAttrib3fv(137, DebuggerMessage.Message.Function.glVertexAttrib3fv), + glVertexAttrib4f(138, DebuggerMessage.Message.Function.glVertexAttrib4f), + glVertexAttrib4fv(139, DebuggerMessage.Message.Function.glVertexAttrib4fv), + glVertexAttribPointer(140, DebuggerMessage.Message.Function.glVertexAttribPointer), + glViewport(141, DebuggerMessage.Message.Function.glViewport), + ; + + public final int index; + public final DebuggerMessage.Message.Function function; + + GLFunction(final int index, final DebuggerMessage.Message.Function function) { + this.index = index; + this.function = function; + } +} \ No newline at end of file diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java new file mode 100644 index 000000000..729592e70 --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java @@ -0,0 +1,89 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import org.eclipse.swt.graphics.Device; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; + +public class MessageData { + public DebuggerMessage.Message.Function function; + public Image image; // texture + public String shader; // shader source + public String[] columns; + public float[] data; // vertex attributes + + public MessageData(final Device device, final DebuggerMessage.Message msg) { + image = null; + shader = null; + data = null; + StringBuilder builder = new StringBuilder(); + function = msg.getFunction(); + ImageData imageData = null; + if (function != DebuggerMessage.Message.Function.ACK) + assert msg.hasTime(); + columns = new String [4]; + columns[0] = function.toString(); + columns[1] = ""; + if (msg.hasTime()) + columns[1] += Float.toString(msg.getTime()); + if (msg.hasClock()) + columns[1] += ":" + Float.toString(msg.getClock()); + columns[2] = Integer.toHexString(msg.getContextId()); + columns[3] = MessageFormatter.Format(msg); + switch (function) { + case glBufferData: + data = MessageProcessor.ReceiveData(msg.getArg0(), msg.getData()); + break; + case glBufferSubData: + data = MessageProcessor.ReceiveData(msg.getArg0(), msg.getData()); + break; + case glShaderSource: + shader = msg.getData().toStringUtf8(); + int index = shader.indexOf('\n'); + columns[3] += " source: " + shader.substring(0, index >= 0 ? index : shader.length()) + "..."; + break; + case glTexImage2D: + if (!msg.hasData()) + break; + imageData = MessageProcessor.ReceiveImage(msg.getArg3(), msg + .getArg4(), msg.getArg6(), msg.getArg7(), msg.getData() + .toByteArray()); + if (null == imageData) + break; + image = new Image(device, imageData); + break; + case glTexSubImage2D: + assert msg.hasData(); + imageData = MessageProcessor.ReceiveImage(msg.getArg4(), msg + .getArg5(), msg.getArg6(), msg.getArg7(), msg.getData() + .toByteArray()); + if (null == imageData) + break; + image = new Image(device, imageData); + break; + case glReadPixels: + if (!msg.hasData()) + break; + imageData = MessageProcessor.ReceiveImage(msg.getArg2(), msg.getArg3(), + msg.getArg4(), msg.getArg5(), msg.getData().toByteArray()); + imageData = imageData.scaledTo(imageData.width, -imageData.height); + image = new Image(device, imageData); + break; + } + } +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageFormatter.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageFormatter.java new file mode 100644 index 000000000..899cf5f38 --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageFormatter.java @@ -0,0 +1,396 @@ +/* + ** Copyright 2011, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +// auto generated by generate_MessageFormatter_java.py" + +package com.android.glesv2debugger; + +import java.nio.ByteBuffer; + +public class MessageFormatter { + + static String FormatFloats(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Float.intBitsToFloat(Integer.reverseBytes(data.getInt())); + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatInts(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Integer.reverseBytes(data.getInt()); + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatUints(int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + long bits = Integer.reverseBytes(data.getInt()) & 0xffffffff; + ret += bits; + if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + static String FormatMatrix(int columns, int count, final ByteBuffer data) { + String ret = "["; + for (int i = 0; i < count; i++) + { + ret += Float.intBitsToFloat(Integer.reverseBytes(data.getInt())); + if (i % columns == columns - 1) + ret += '\n'; + else if (i < count - 1) + ret += ", "; + } + return ret + "]"; + } + + public static String Format(final DebuggerMessage.Message msg) { + String str; + switch (msg.getFunction()) { + case glActiveTexture: + str = String.format("%s (texture=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glAttachShader: + str = String.format("%s (program=%s, shader=%s)", "void", msg.getArg0(), msg.getArg1()); break; + case glBindAttribLocation: + str = String.format("%s (program=%s, index=%s, name=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getData().toStringUtf8()); break; + case glBindBuffer: + str = String.format("%s (target=%s, buffer=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glBindFramebuffer: + str = String.format("%s (target=%s, framebuffer=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glBindRenderbuffer: + str = String.format("%s (target=%s, renderbuffer=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glBindTexture: + str = String.format("%s (target=%s, texture=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glBlendColor: + str = String.format("%s (red=%s, green=%s, blue=%s, alpha=%s)", "void", Float.intBitsToFloat(msg.getArg0()), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3())); break; + case glBlendEquation: + str = String.format("%s (mode=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glBlendEquationSeparate: + str = String.format("%s (modeRGB=%s, modeAlpha=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1())); break; + case glBlendFunc: + str = String.format("%s (sfactor=%s, dfactor=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1())); break; + case glBlendFuncSeparate: + str = String.format("%s (srcRGB=%s, dstRGB=%s, srcAlpha=%s, dstAlpha=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), GLEnum.valueOf(msg.getArg3())); break; + case glBufferData: + str = String.format("%s (target=%s, size=%s, data=%s, usage=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), GLEnum.valueOf(msg.getArg3())); break; + case glBufferSubData: + str = String.format("%s (target=%s, offset=%s, size=%s, data=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), "0x" + Integer.toHexString(msg.getArg3())); break; + case glCheckFramebufferStatus: + str = String.format("%s (target=%s)", GLEnum.valueOf(msg.getRet()), GLEnum.valueOf(msg.getArg0())); break; + case glClear: + str = String.format("%s (mask=%s)", "void", msg.getArg0()); break; + case glClearColor: + str = String.format("%s (red=%s, green=%s, blue=%s, alpha=%s)", "void", Float.intBitsToFloat(msg.getArg0()), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3())); break; + case glClearDepthf: + str = String.format("%s (depth=%s)", "void", Float.intBitsToFloat(msg.getArg0())); break; + case glClearStencil: + str = String.format("%s (s=%s)", "void", msg.getArg0()); break; + case glColorMask: + str = String.format("%s (red=%s, green=%s, blue=%s, alpha=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3()); break; + case glCompileShader: + str = String.format("%s (shader=%s)", "void", msg.getArg0()); break; + case glCompressedTexImage2D: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, level=%s, internalformat=%s, width=%s, height=%s, border=%s, imageSize=%s, data=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), GLEnum.valueOf(msg.getArg2()), msg.getArg3(), msg.getArg4(), msg.getArg5(), msg.getArg6(), "0x" + Integer.toHexString(msg.getArg7())); break; + case glCompressedTexSubImage2D: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, level=%s, xoffset=%s, yoffset=%s, width=%s, height=%s, format=%s, imageSize=%s, data=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg4(), msg.getArg5(), GLEnum.valueOf(msg.getArg6()), msg.getArg7(), "0x" + Integer.toHexString(msg.getArg8())); break; + case glCopyTexImage2D: + str = String.format("%s (target=%s, level=%s, internalformat=%s, x=%s, y=%s, width=%s, height=%s, border=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), GLEnum.valueOf(msg.getArg2()), msg.getArg3(), msg.getArg4(), msg.getArg5(), msg.getArg6(), msg.getArg7()); break; + case glCopyTexSubImage2D: + str = String.format("%s (target=%s, level=%s, xoffset=%s, yoffset=%s, x=%s, y=%s, width=%s, height=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg4(), msg.getArg5(), msg.getArg6(), msg.getArg7()); break; + case glCreateProgram: + str = String.format("%s ()", msg.getRet()); break; + case glCreateShader: + str = String.format("%s (type=%s)", msg.getRet(), GLEnum.valueOf(msg.getArg0())); break; + case glCullFace: + str = String.format("%s (mode=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glDeleteBuffers: + str = String.format("%s (n=%s, buffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glDeleteFramebuffers: + str = String.format("%s (n=%s, framebuffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glDeleteProgram: + str = String.format("%s (program=%s)", "void", msg.getArg0()); break; + case glDeleteRenderbuffers: + str = String.format("%s (n=%s, renderbuffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glDeleteShader: + str = String.format("%s (shader=%s)", "void", msg.getArg0()); break; + case glDeleteTextures: + str = String.format("%s (n=%s, textures=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glDepthFunc: + str = String.format("%s (func=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glDepthMask: + str = String.format("%s (flag=%s)", "void", msg.getArg0()); break; + case glDepthRangef: + str = String.format("%s (zNear=%s, zFar=%s)", "void", Float.intBitsToFloat(msg.getArg0()), Float.intBitsToFloat(msg.getArg1())); break; + case glDetachShader: + str = String.format("%s (program=%s, shader=%s)", "void", msg.getArg0(), msg.getArg1()); break; + case glDisable: + str = String.format("%s (cap=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glDisableVertexAttribArray: + str = String.format("%s (index=%s)", "void", msg.getArg0()); break; + case glDrawArrays: + str = String.format("%s (mode=%s, first=%s, count=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2()); break; + case glDrawElements: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (mode=%s, count=%s, type=%s, indices=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), GLEnum.valueOf(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3())); break; + case glEnable: + str = String.format("%s (cap=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glEnableVertexAttribArray: + str = String.format("%s (index=%s)", "void", msg.getArg0()); break; + case glFinish: + str = String.format("%s ()", "void"); break; + case glFlush: + str = String.format("%s ()", "void"); break; + case glFramebufferRenderbuffer: + str = String.format("%s (target=%s, attachment=%s, renderbuffertarget=%s, renderbuffer=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), msg.getArg3()); break; + case glFramebufferTexture2D: + str = String.format("%s (target=%s, attachment=%s, textarget=%s, texture=%s, level=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), msg.getArg3(), msg.getArg4()); break; + case glFrontFace: + str = String.format("%s (mode=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glGenBuffers: + str = String.format("%s (n=%s, buffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glGenerateMipmap: + str = String.format("%s (target=%s)", "void", GLEnum.valueOf(msg.getArg0())); break; + case glGenFramebuffers: + str = String.format("%s (n=%s, framebuffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glGenRenderbuffers: + str = String.format("%s (n=%s, renderbuffers=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glGenTextures: + str = String.format("%s (n=%s, textures=%s)", "void", msg.getArg0(), FormatUints(1 * msg.getArg0(), msg.getData().asReadOnlyByteBuffer())); break; + case glGetActiveAttrib: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, index=%s, bufsize=%s, length=%s, size=%s, type=%s, name=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), "0x" + Integer.toHexString(msg.getArg3()), "0x" + Integer.toHexString(msg.getArg4()), "0x" + Integer.toHexString(msg.getArg5()), msg.getData().toStringUtf8()); break; + case glGetActiveUniform: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, index=%s, bufsize=%s, length=%s, size=%s, type=%s, name=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), "0x" + Integer.toHexString(msg.getArg3()), "0x" + Integer.toHexString(msg.getArg4()), "0x" + Integer.toHexString(msg.getArg5()), msg.getData().toStringUtf8()); break; + case glGetAttachedShaders: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, maxcount=%s, count=%s, shaders=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3())); break; + case glGetAttribLocation: + str = String.format("%s (program=%s, name=%s)", msg.getRet(), msg.getArg0(), msg.getData().toStringUtf8()); break; + case glGetBooleanv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), "0x" + Integer.toHexString(msg.getArg1())); break; + case glGetBufferParameteriv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetError: + str = String.format("%s ()", GLEnum.valueOf(msg.getRet())); break; + case glGetFloatv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), "0x" + Integer.toHexString(msg.getArg1())); break; + case glGetFramebufferAttachmentParameteriv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, attachment=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3())); break; + case glGetIntegerv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), "0x" + Integer.toHexString(msg.getArg1())); break; + case glGetProgramiv: + str = String.format("%s (program=%s, pname=%s, params=%s)", "void", msg.getArg0(), GLEnum.valueOf(msg.getArg1()), FormatInts(1, msg.getData().asReadOnlyByteBuffer())); break; + case glGetProgramInfoLog: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, bufsize=%s, length=%s, infolog=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), msg.getData().toStringUtf8()); break; + case glGetRenderbufferParameteriv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetShaderiv: + str = String.format("%s (shader=%s, pname=%s, params=%s)", "void", msg.getArg0(), GLEnum.valueOf(msg.getArg1()), FormatInts(1, msg.getData().asReadOnlyByteBuffer())); break; + case glGetShaderInfoLog: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (shader=%s, bufsize=%s, length=%s, infolog=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), msg.getData().toStringUtf8()); break; + case glGetShaderPrecisionFormat: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (shadertype=%s, precisiontype=%s, range=%s, precision=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3())); break; + case glGetShaderSource: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (shader=%s, bufsize=%s, length=%s, source=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), msg.getData().toStringUtf8()); break; + case glGetString: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (name=%s)", "0x" + Integer.toHexString(msg.getRet()), GLEnum.valueOf(msg.getArg0())); break; + case glGetTexParameterfv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetTexParameteriv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetUniformfv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, location=%s, params=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetUniformiv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (program=%s, location=%s, params=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetUniformLocation: + str = String.format("%s (program=%s, name=%s)", msg.getRet(), msg.getArg0(), msg.getData().toStringUtf8()); break; + case glGetVertexAttribfv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (index=%s, pname=%s, params=%s)", "void", msg.getArg0(), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetVertexAttribiv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (index=%s, pname=%s, params=%s)", "void", msg.getArg0(), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glGetVertexAttribPointerv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (index=%s, pname=%s, pointer=%s)", "void", msg.getArg0(), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glHint: + str = String.format("%s (target=%s, mode=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1())); break; + case glIsBuffer: + str = String.format("%s (buffer=%s)", msg.getRet(), msg.getArg0()); break; + case glIsEnabled: + str = String.format("%s (cap=%s)", msg.getRet(), GLEnum.valueOf(msg.getArg0())); break; + case glIsFramebuffer: + str = String.format("%s (framebuffer=%s)", msg.getRet(), msg.getArg0()); break; + case glIsProgram: + str = String.format("%s (program=%s)", msg.getRet(), msg.getArg0()); break; + case glIsRenderbuffer: + str = String.format("%s (renderbuffer=%s)", msg.getRet(), msg.getArg0()); break; + case glIsShader: + str = String.format("%s (shader=%s)", msg.getRet(), msg.getArg0()); break; + case glIsTexture: + str = String.format("%s (texture=%s)", msg.getRet(), msg.getArg0()); break; + case glLineWidth: + str = String.format("%s (width=%s)", "void", Float.intBitsToFloat(msg.getArg0())); break; + case glLinkProgram: + str = String.format("%s (program=%s)", "void", msg.getArg0()); break; + case glPixelStorei: + str = String.format("%s (pname=%s, param=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glPolygonOffset: + str = String.format("%s (factor=%s, units=%s)", "void", Float.intBitsToFloat(msg.getArg0()), Float.intBitsToFloat(msg.getArg1())); break; + case glReadPixels: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (x=%s, y=%s, width=%s, height=%s, format=%s, type=%s, pixels=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3(), GLEnum.valueOf(msg.getArg4()), GLEnum.valueOf(msg.getArg5()), "0x" + Integer.toHexString(msg.getArg6())); break; + case glReleaseShaderCompiler: + str = String.format("%s ()", "void"); break; + case glRenderbufferStorage: + str = String.format("%s (target=%s, internalformat=%s, width=%s, height=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), msg.getArg2(), msg.getArg3()); break; + case glSampleCoverage: + str = String.format("%s (value=%s, invert=%s)", "void", Float.intBitsToFloat(msg.getArg0()), msg.getArg1()); break; + case glScissor: + str = String.format("%s (x=%s, y=%s, width=%s, height=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3()); break; + case glShaderBinary: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (n=%s, shaders=%s, binaryformat=%s, binary=%s, length=%s)", "void", msg.getArg0(), "0x" + Integer.toHexString(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3()), msg.getArg4()); break; + case glShaderSource: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (shader=%s, count=%s, string=%s, length=%s)", "void", msg.getArg0(), msg.getArg1(), "0x" + Integer.toHexString(msg.getArg2()), "0x" + Integer.toHexString(msg.getArg3())); break; + case glStencilFunc: + str = String.format("%s (func=%s, ref=%s, mask=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2()); break; + case glStencilFuncSeparate: + str = String.format("%s (face=%s, func=%s, ref=%s, mask=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), msg.getArg2(), msg.getArg3()); break; + case glStencilMask: + str = String.format("%s (mask=%s)", "void", msg.getArg0()); break; + case glStencilMaskSeparate: + str = String.format("%s (face=%s, mask=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1()); break; + case glStencilOp: + str = String.format("%s (fail=%s, zfail=%s, zpass=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2())); break; + case glStencilOpSeparate: + str = String.format("%s (face=%s, fail=%s, zfail=%s, zpass=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), GLEnum.valueOf(msg.getArg2()), GLEnum.valueOf(msg.getArg3())); break; + case glTexImage2D: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, level=%s, internalformat=%s, width=%s, height=%s, border=%s, format=%s, type=%s, pixels=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg4(), msg.getArg5(), GLEnum.valueOf(msg.getArg6()), GLEnum.valueOf(msg.getArg7()), "0x" + Integer.toHexString(msg.getArg8())); break; + case glTexParameterf: + str = String.format("%s (target=%s, pname=%s, param=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), Float.intBitsToFloat(msg.getArg2())); break; + case glTexParameterfv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glTexParameteri: + str = String.format("%s (target=%s, pname=%s, param=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), msg.getArg2()); break; + case glTexParameteriv: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, pname=%s, params=%s)", "void", GLEnum.valueOf(msg.getArg0()), GLEnum.valueOf(msg.getArg1()), "0x" + Integer.toHexString(msg.getArg2())); break; + case glTexSubImage2D: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (target=%s, level=%s, xoffset=%s, yoffset=%s, width=%s, height=%s, format=%s, type=%s, pixels=%s)", "void", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg4(), msg.getArg5(), GLEnum.valueOf(msg.getArg6()), GLEnum.valueOf(msg.getArg7()), "0x" + Integer.toHexString(msg.getArg8())); break; + case glUniform1f: + str = String.format("%s (location=%s, x=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1())); break; + case glUniform1fv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatFloats(1 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform1i: + str = String.format("%s (location=%s, x=%s)", "void", msg.getArg0(), msg.getArg1()); break; + case glUniform1iv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatInts(1 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform2f: + str = String.format("%s (location=%s, x=%s, y=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2())); break; + case glUniform2fv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatFloats(2 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform2i: + str = String.format("%s (location=%s, x=%s, y=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2()); break; + case glUniform2iv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatInts(2 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform3f: + str = String.format("%s (location=%s, x=%s, y=%s, z=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3())); break; + case glUniform3fv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatFloats(3 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform3i: + str = String.format("%s (location=%s, x=%s, y=%s, z=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3()); break; + case glUniform3iv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatInts(3 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform4f: + str = String.format("%s (location=%s, x=%s, y=%s, z=%s, w=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3()), Float.intBitsToFloat(msg.getArg4())); break; + case glUniform4fv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatFloats(4 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniform4i: + str = String.format("%s (location=%s, x=%s, y=%s, z=%s, w=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg4()); break; + case glUniform4iv: + str = String.format("%s (location=%s, count=%s, v=%s)", "void", msg.getArg0(), msg.getArg1(), FormatInts(4 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniformMatrix2fv: + str = String.format("%s (location=%s, count=%s, transpose=%s, value=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), FormatMatrix(2, 4 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniformMatrix3fv: + str = String.format("%s (location=%s, count=%s, transpose=%s, value=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), FormatMatrix(3, 9 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUniformMatrix4fv: + str = String.format("%s (location=%s, count=%s, transpose=%s, value=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), FormatMatrix(4, 16 * msg.getArg1(), msg.getData().asReadOnlyByteBuffer())); break; + case glUseProgram: + str = String.format("%s (program=%s)", "void", msg.getArg0()); break; + case glValidateProgram: + str = String.format("%s (program=%s)", "void", msg.getArg0()); break; + case glVertexAttrib1f: + str = String.format("%s (indx=%s, x=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1())); break; + case glVertexAttrib1fv: + str = String.format("%s (indx=%s, values=%s)", "void", msg.getArg0(), FormatFloats(1, msg.getData().asReadOnlyByteBuffer())); break; + case glVertexAttrib2f: + str = String.format("%s (indx=%s, x=%s, y=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2())); break; + case glVertexAttrib2fv: + str = String.format("%s (indx=%s, values=%s)", "void", msg.getArg0(), FormatFloats(2, msg.getData().asReadOnlyByteBuffer())); break; + case glVertexAttrib3f: + str = String.format("%s (indx=%s, x=%s, y=%s, z=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3())); break; + case glVertexAttrib3fv: + str = String.format("%s (indx=%s, values=%s)", "void", msg.getArg0(), FormatFloats(3, msg.getData().asReadOnlyByteBuffer())); break; + case glVertexAttrib4f: + str = String.format("%s (indx=%s, x=%s, y=%s, z=%s, w=%s)", "void", msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), Float.intBitsToFloat(msg.getArg2()), Float.intBitsToFloat(msg.getArg3()), Float.intBitsToFloat(msg.getArg4())); break; + case glVertexAttrib4fv: + str = String.format("%s (indx=%s, values=%s)", "void", msg.getArg0(), FormatFloats(4, msg.getData().asReadOnlyByteBuffer())); break; + case glVertexAttribPointer: + // FIXME: this function uses pointers, debugger may send data in msg.data + str = String.format("%s (indx=%s, size=%s, type=%s, normalized=%s, stride=%s, ptr=%s)", "void", msg.getArg0(), msg.getArg1(), GLEnum.valueOf(msg.getArg2()), msg.getArg3(), msg.getArg4(), "0x" + Integer.toHexString(msg.getArg5())); break; + case glViewport: + str = String.format("%s (x=%s, y=%s, width=%s, height=%s)", "void", msg.getArg0(), msg.getArg1(), msg.getArg2(), msg.getArg3()); break; + default: + str = msg.toString(); + } + return str; + } +} \ No newline at end of file diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java new file mode 100644 index 000000000..0c4a0053a --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java @@ -0,0 +1,148 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import com.google.protobuf.ByteString; + +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.PaletteData; + +import java.nio.ByteBuffer; + +public class MessageProcessor { + static void showError(final String message) { + // need to call SWT from UI thread + MessageDialog.openError(null, "MessageProcessor", message); + } + + static byte[] RLEDecode(final byte[] data) { + byte dataSize = data[0]; + int a = data[1] & 0xff, b = data[2] & 0xff, c = data[3] & 0xff, d = data[4] & 0xff; + int count = (d << 24) | (c << 16) | (b << 8) | a; + byte[] buffer = new byte[count * dataSize]; + int write = 0; + int i = 5; + for (i = 5; i < data.length;) { + byte flag = data[i]; + int repeat = (flag & 0x7f) + 1; + assert 0 < repeat && repeat < 129; + i++; + if (0x80 == (flag & 0x80)) { + for (int j = 0; j < repeat; j++) + for (int k = 0; k < dataSize; k++) + buffer[write++] = data[i + k]; + i += dataSize; + } else // literal runs + { + for (int j = 0; j < repeat; j++) + for (int k = 0; k < dataSize; k++) + buffer[write++] = data[i++]; + } + } + assert write == count * dataSize; + assert i == data.length; + return buffer; + } + + public static ImageData ReceiveImage(int width, int height, int format, + int type, byte[] data) { + assert width > 0 && height > 0; + int bpp = 0; + int redMask = 0, blueMask = 0, greenMask = 0; + switch (GLEnum.valueOf(type)) { + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + format = type; + break; + case GL_UNSIGNED_BYTE: + break; + default: + showError("unsupported texture type " + type); + } + + switch (GLEnum.valueOf(format)) { + case GL_ALPHA: + case GL_LUMINANCE: + redMask = blueMask = greenMask = 0xff; + bpp = 8; + break; + case GL_LUMINANCE_ALPHA: + blueMask = 0xff; + redMask = 0xff00; + bpp = 16; + break; + case GL_RGB: + blueMask = 0xff; + greenMask = 0xff00; + redMask = 0xff0000; + bpp = 24; + break; + case GL_RGBA: + blueMask = 0xff00; + greenMask = 0xff0000; + redMask = 0xff000000; + bpp = 32; + break; + case GL_UNSIGNED_SHORT_5_6_5: + blueMask = ((1 << 5) - 1) << 0; + greenMask = ((1 << 6) - 1) << 5; + redMask = ((1 << 5) - 1) << 11; + bpp = 16; + break; + case GL_UNSIGNED_SHORT_4_4_4_4: + blueMask = ((1 << 4) - 1) << 4; + greenMask = ((1 << 4) - 1) << 8; + redMask = ((1 << 4) - 1) << 12; + bpp = 16; + break; + case GL_UNSIGNED_SHORT_5_5_5_1: + blueMask = ((1 << 5) - 1) << 1; + greenMask = ((1 << 5) - 1) << 6; + redMask = ((1 << 5) - 1) << 11; + bpp = 16; + break; + default: + showError("unsupported texture format: " + format); + return null; + } + // data = RLEDecode(data); + PaletteData palette = new PaletteData(redMask, greenMask, blueMask); + return new ImageData(width, height, bpp, palette, 1, data); + } + + static public float[] ReceiveData(int target, final ByteString data) { + ByteBuffer buffer = data.asReadOnlyByteBuffer(); + GLEnum type = GLEnum.valueOf(target); + if (type == GLEnum.GL_ARRAY_BUFFER) { + float[] elements = new float[buffer.remaining() / 4]; + buffer.asFloatBuffer().get(elements); + return elements; + } else if (type == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { + // usually unsigned short + float[] elements = new float[buffer.remaining() / 2]; + for (int i = 0; i < elements.length; i++) { + int bits = Short.reverseBytes(buffer.getShort()) & 0xffff; + elements[i] = bits; + } + return elements; + } else + return null; + + } +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java new file mode 100644 index 000000000..9f91d404b --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java @@ -0,0 +1,263 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import com.android.glesv2debugger.DebuggerMessage.Message.Function; +import com.android.glesv2debugger.DebuggerMessage.Message.Type; + +import java.io.EOFException; +import java.io.IOException; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.net.Socket; +import java.util.ArrayList; +import java.util.HashMap; + +public class MessageQueue implements Runnable { + + boolean running = false; + Thread thread = null; + ArrayList complete = new ArrayList(); + ArrayList commands = new ArrayList(); + SampleView sampleView; + + public MessageQueue(SampleView sampleView) { + this.sampleView = sampleView; + } + + public void Start() { + if (running) + return; + running = true; + thread = new Thread(this); + thread.start(); + } + + public void Stop() { + if (!running) + return; + running = false; + } + + public boolean IsRunning() { + return running; + } + + void SendCommands(final DataOutputStream dos, final int contextId) throws IOException { + synchronized (commands) { + for (int i = 0; i < commands.size(); i++) { + DebuggerMessage.Message command = commands.get(i); + if (command.getContextId() == contextId || contextId == 0) { // FIXME: + // proper + // context + // id + SendMessage(dos, command); + commands.remove(i); + i--; + } + } + } + SendResponse(dos, contextId, DebuggerMessage.Message.Function.SKIP); + } + + public void AddCommand(DebuggerMessage.Message command) { + synchronized (commands) { + commands.add(command); + } + } + + @Override + public void run() { + Socket socket = new Socket(); + DataInputStream dis = null; + DataOutputStream dos = null; + HashMap> incoming = new HashMap>(); + try { + socket.connect(new java.net.InetSocketAddress("127.0.0.1", 5039)); + dis = new DataInputStream(socket.getInputStream()); + dos = new DataOutputStream(socket.getOutputStream()); + } catch (Exception e) { + running = false; + Error(e); + } + + try { + while (running) { + DebuggerMessage.Message msg = null; + if (incoming.size() > 0) { // find queued incoming + for (ArrayList messages : incoming + .values()) + if (messages.size() > 0) { + msg = messages.get(0); + messages.remove(0); + break; + } + } + if (null == msg) { // get incoming from network + msg = ReadMessage(dis); + if (msg.getExpectResponse()) { + if (msg.getType() == Type.BeforeCall) + SendResponse(dos, msg.getContextId(), + DebuggerMessage.Message.Function.CONTINUE); + else if (msg.getType() == Type.AfterCall) + // after GL function call + SendCommands(dos, 0); // FIXME: proper context id + // SendResponse(dos, msg.getContextId(), + // DebuggerMessage.Message.Function.SKIP); + else if (msg.getType() == Type.Response) + ; + else + assert false; + } + } + + int contextId = msg.getContextId(); + if (!incoming.containsKey(contextId)) + incoming.put(contextId, + new ArrayList()); + + // FIXME: the expected sequence will change for interactive mode + while (msg.getType() == Type.BeforeCall) { + DebuggerMessage.Message next = null; + // get existing message part for this context + ArrayList messages = incoming + .get(contextId); + if (messages.size() > 0) { + next = messages.get(0); + messages.remove(0); + } + if (null == next) { // read new part for message + next = ReadMessage(dis); + + if (next.getExpectResponse()) { + if (next.getType() == Type.BeforeCall) + SendResponse( + dos, + next.getContextId(), + DebuggerMessage.Message.Function.CONTINUE); + else if (next.getType() == Type.AfterCall) + SendCommands(dos, 0); // FIXME: proper context id + else if (msg.getType() == Type.Response) + ; + else + assert false; + } + + if (next.getContextId() != contextId) { + // message part not for this context + if (!incoming.containsKey(next.getContextId())) + incoming.put( + next.getContextId(), + new ArrayList()); + incoming.get(next.getContextId()).add(next); + continue; + } + } + + DebuggerMessage.Message.Builder builder = msg.toBuilder(); + // builder.mergeFrom(next); seems to merge incorrectly + if (next.hasRet()) + builder.setRet(next.getRet()); + if (next.hasTime()) + builder.setTime(next.getTime()); + if (next.hasData()) + builder.setData(next.getData()); + builder.setType(next.getType()); + msg = builder.build(); + } + + synchronized (complete) { + complete.add(msg); + } + } + socket.close(); + } catch (Exception e) { + Error(e); + running = false; + } + } + + public DebuggerMessage.Message RemoveMessage(int contextId) { + synchronized (complete) { + if (complete.size() == 0) + return null; + if (0 == contextId) // get a message of any + { + DebuggerMessage.Message msg = complete.get(0); + complete.remove(0); + return msg; + } + for (int i = 0; i < complete.size(); i++) { + DebuggerMessage.Message msg = complete.get(i); + if (msg.getContextId() == contextId) { + complete.remove(i); + return msg; + } + } + } + return null; + } + + DebuggerMessage.Message ReadMessage(final DataInputStream dis) + throws IOException { + int len = 0; + try { + len = dis.readInt(); + } catch (EOFException e) { + Error(new Exception("EOF")); + } + byte[] buffer = new byte[len]; + int readLen = 0; + while (readLen < len) { + int read = -1; + try { + read = dis.read(buffer, readLen, len - readLen); + } catch (EOFException e) { + Error(new Exception("EOF")); + } + if (read < 0) { + Error(new Exception("read length = " + read)); + return null; + } else + readLen += read; + } + DebuggerMessage.Message msg = DebuggerMessage.Message.parseFrom(buffer); + return msg; + } + + void SendMessage(final DataOutputStream dos, final DebuggerMessage.Message message) + throws IOException { + final byte[] data = message.toByteArray(); + dos.writeInt(data.length); + dos.write(data); + } + + void SendResponse(final DataOutputStream dos, final int contextId, + final DebuggerMessage.Message.Function function) throws IOException { + DebuggerMessage.Message.Builder builder = DebuggerMessage.Message + .newBuilder(); + builder.setContextId(contextId); + builder.setFunction(function); + builder.setType(Type.Response); + builder.setExpectResponse(false); + SendMessage(dos, builder.build()); + } + + void Error(Exception e) { + sampleView.showError(e); + } +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java b/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java new file mode 100755 index 000000000..05fe51bbd --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java @@ -0,0 +1,587 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import com.android.glesv2debugger.DebuggerMessage.Message.Function; +import com.android.glesv2debugger.DebuggerMessage.Message.Prop; +import com.android.glesv2debugger.DebuggerMessage.Message.Type; + +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IMenuListener; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.IToolBarManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.action.Separator; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ColumnWeightData; +import org.eclipse.jface.viewers.DoubleClickEvent; +import org.eclipse.jface.viewers.IDoubleClickListener; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredContentProvider; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.jface.viewers.TableLayout; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.jface.viewers.ViewerFilter; +import org.eclipse.jface.viewers.ViewerSorter; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.Menu; +import org.eclipse.swt.widgets.ScrollBar; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.IWorkbenchActionConstants; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.part.ViewPart; + +import java.util.ArrayList; + +/** + * This sample class demonstrates how to plug-in a new workbench view. The view + * shows data obtained from the model. The sample creates a dummy model on the + * fly, but a real implementation would connect to the model available either in + * this or another plug-in (e.g. the workspace). The view is connected to the + * model using a content provider. + *

+ * The view uses a label provider to define how model objects should be + * presented in the view. Each view can present the same model objects using + * different labels and icons, if needed. Alternatively, a single label provider + * can be shared between views in order to ensure that objects of the same type + * are presented in the same way everywhere. + *

+ */ + +public class SampleView extends ViewPart implements Runnable { + + boolean running = false; + Thread thread; + MessageQueue messageQueue; + ViewContentProvider viewContentProvider; + /** + * The ID of the view as specified by the extension. + */ + public static final String ID = "glesv2debuggerclient.views.SampleView"; + + TableViewer viewer; + org.eclipse.swt.widgets.Canvas canvas; + Action actionConnect; // connect / disconnect + Action doubleClickAction; + Action actionAutoScroll; + Action actionFilter; + Action actionCapture; + + Point origin = new Point(0, 0); // for smooth scrolling canvas + String[] filters = null; + + /* + * The content provider class is responsible for providing objects to the + * view. It can wrap existing objects in adapters or simply return objects + * as-is. These objects may be sensitive to the current input of the view, + * or ignore it and always show the same content (like Task List, for + * example). + */ + + class ViewContentProvider implements IStructuredContentProvider { + ArrayList entries = new ArrayList(); + + public void add(final ArrayList msgs) { + entries.addAll(msgs); + viewer.getTable().getDisplay().syncExec(new Runnable() { + @Override + public void run() { + viewer.add(msgs.toArray()); + org.eclipse.swt.widgets.ScrollBar bar = viewer + .getTable().getVerticalBar(); + if (null != bar && actionAutoScroll.isChecked()) { + bar.setSelection(bar.getMaximum()); + viewer.getTable().setSelection( + entries.size() - 1); + } + } + }); + } + + @Override + public void inputChanged(Viewer v, Object oldInput, Object newInput) { + // showMessage("ViewContentProvider::inputChanged"); + } + + @Override + public void dispose() { + } + + @Override + public Object[] getElements(Object parent) { + return entries.toArray(); + } + } + + class ViewLabelProvider extends LabelProvider implements + ITableLabelProvider { + @Override + public String getColumnText(Object obj, int index) { + com.android.glesv2debugger.MessageData msgData = (com.android.glesv2debugger.MessageData) obj; + if (null == msgData) + return getText(obj); + if (index >= msgData.columns.length) + return null; + return msgData.columns[index]; + } + + @Override + public Image getColumnImage(Object obj, int index) { + if (index > 0) + return null; + com.android.glesv2debugger.MessageData msgData = (com.android.glesv2debugger.MessageData) obj; + if (null == msgData) + return getImage(obj); + if (null == msgData.image) + return getImage(obj); + return msgData.image; + } + + @Override + public Image getImage(Object obj) { + return PlatformUI.getWorkbench().getSharedImages() + .getImage(ISharedImages.IMG_OBJ_ELEMENT); + } + } + + class NameSorter extends ViewerSorter { + } + + class Filter extends ViewerFilter { + @Override + public boolean select(Viewer viewer, Object parentElement, + Object element) { + com.android.glesv2debugger.MessageData msgData = (com.android.glesv2debugger.MessageData) element; + if (null == filters) + return true; + for (int i = 0; i < filters.length; i++) + if (msgData.columns[0].contains(filters[i])) + return true; + return false; + } + } + + /** + * The constructor. + */ + public SampleView() { + messageQueue = new MessageQueue(this); + } + + public void CreateTable(Composite parent) { + Table table = new Table(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI + | SWT.FULL_SELECTION); + TableLayout layout = new TableLayout(); + table.setLayout(layout); + table.setLinesVisible(true); + table.setHeaderVisible(true); + + String[] headings = { + "Name", "Elapsed (ms)", "Context", "Detail" + }; + int[] weights = { + 35, 16, 16, 60 + }; + int[] widths = { + 120, 90, 90, 100 + }; + for (int i = 0; i < headings.length; i++) { + layout.addColumnData(new ColumnWeightData(weights[i], widths[i], + true)); + TableColumn nameCol = new TableColumn(table, SWT.NONE, i); + nameCol.setText(headings[i]); + } + + viewer = new TableViewer(table); + viewContentProvider = new ViewContentProvider(); + viewer.setContentProvider(viewContentProvider); + viewer.setLabelProvider(new ViewLabelProvider()); + // viewer.setSorter(new NameSorter()); + viewer.setInput(getViewSite()); + viewer.setFilters(new ViewerFilter[] { + new Filter() + }); + } + + /** + * This is a callback that will allow us to create the viewer and initialize + * it. + */ + @Override + public void createPartControl(Composite parent) { + CreateTable(parent); + + // Create the help context id for the viewer's control + PlatformUI.getWorkbench().getHelpSystem() + .setHelp(viewer.getControl(), "GLESv2DebuggerClient.viewer"); + makeActions(); + hookContextMenu(); + hookDoubleClickAction(); + hookSelectionChanged(); + contributeToActionBars(); + + canvas = new Canvas(parent, SWT.NO_BACKGROUND | SWT.NO_REDRAW_RESIZE + | SWT.V_SCROLL | SWT.H_SCROLL); + final ScrollBar hBar = canvas.getHorizontalBar(); + hBar.addListener(SWT.Selection, new Listener() { + @Override + public void handleEvent(Event e) { + if (null == canvas.getBackgroundImage()) + return; + Image image = canvas.getBackgroundImage(); + int hSelection = hBar.getSelection(); + int destX = -hSelection - origin.x; + Rectangle rect = image.getBounds(); + canvas.scroll(destX, 0, 0, 0, rect.width, rect.height, false); + origin.x = -hSelection; + } + }); + final ScrollBar vBar = canvas.getVerticalBar(); + vBar.addListener(SWT.Selection, new Listener() { + @Override + public void handleEvent(Event e) { + if (null == canvas.getBackgroundImage()) + return; + Image image = canvas.getBackgroundImage(); + int vSelection = vBar.getSelection(); + int destY = -vSelection - origin.y; + Rectangle rect = image.getBounds(); + canvas.scroll(0, destY, 0, 0, rect.width, rect.height, false); + origin.y = -vSelection; + } + }); + canvas.addListener(SWT.Resize, new Listener() { + @Override + public void handleEvent(Event e) { + if (null == canvas.getBackgroundImage()) + return; + Image image = canvas.getBackgroundImage(); + Rectangle rect = image.getBounds(); + Rectangle client = canvas.getClientArea(); + hBar.setMaximum(rect.width); + vBar.setMaximum(rect.height); + hBar.setThumb(Math.min(rect.width, client.width)); + vBar.setThumb(Math.min(rect.height, client.height)); + int hPage = rect.width - client.width; + int vPage = rect.height - client.height; + int hSelection = hBar.getSelection(); + int vSelection = vBar.getSelection(); + if (hSelection >= hPage) { + if (hPage <= 0) + hSelection = 0; + origin.x = -hSelection; + } + if (vSelection >= vPage) { + if (vPage <= 0) + vSelection = 0; + origin.y = -vSelection; + } + canvas.redraw(); + } + }); + canvas.addListener(SWT.Paint, new Listener() { + @Override + public void handleEvent(Event e) { + if (null == canvas.getBackgroundImage()) + return; + Image image = canvas.getBackgroundImage(); + GC gc = e.gc; + gc.drawImage(image, origin.x, origin.y); + Rectangle rect = image.getBounds(); + Rectangle client = canvas.getClientArea(); + int marginWidth = client.width - rect.width; + if (marginWidth > 0) { + gc.fillRectangle(rect.width, 0, marginWidth, client.height); + } + int marginHeight = client.height - rect.height; + if (marginHeight > 0) { + gc.fillRectangle(0, rect.height, client.width, marginHeight); + } + } + }); + } + + private void hookContextMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { + SampleView.this.fillContextMenu(manager); + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); + } + + private void contributeToActionBars() { + IActionBars bars = getViewSite().getActionBars(); + fillLocalPullDown(bars.getMenuManager()); + fillLocalToolBar(bars.getToolBarManager()); + } + + private void fillLocalPullDown(IMenuManager manager) { + // manager.add(actionConnect); + // manager.add(new Separator()); + // manager.add(actionDisconnect); + } + + private void fillContextMenu(IMenuManager manager) { + // manager.add(actionConnect); + // manager.add(actionDisconnect); + // Other plug-ins can contribute there actions here + manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + + private void fillLocalToolBar(final IToolBarManager manager) { + manager.add(actionConnect); + final Shell shell = this.getViewSite().getShell(); + actionAutoScroll = new Action("Auto Scroll", Action.AS_CHECK_BOX) { + @Override + public void run() { + } + }; + actionAutoScroll.setChecked(true); + manager.add(actionAutoScroll); + + actionFilter = new Action("*", Action.AS_DROP_DOWN_MENU) { + @Override + public void run() { + org.eclipse.jface.dialogs.InputDialog dialog = new org.eclipse.jface.dialogs.InputDialog( + shell, "Contains Filter", + "case sensitive substring or *", + actionFilter.getText(), null); + if (dialog.OK == dialog.open()) { + actionFilter.setText(dialog.getValue()); + manager.update(true); + filters = dialog.getValue().split("\\|"); + if (filters.length == 1 && filters[0].equals("*")) + filters = null; + viewer.refresh(); + } + + } + }; + manager.add(actionFilter); + + actionCapture = new Action("Capture", Action.AS_CHECK_BOX) { + @Override + public void run() { + DebuggerMessage.Message.Builder builder = DebuggerMessage.Message.newBuilder(); + builder.setContextId(0); // FIXME: proper context id + builder.setType(Type.Response); + builder.setExpectResponse(false); + builder.setFunction(Function.SETPROP); + builder.setProp(Prop.Capture); + builder.setArg0(isChecked() ? 1 : 0); + messageQueue.AddCommand(builder.build()); + manager.update(true); + } + }; + actionCapture.setChecked(false); + manager.add(actionCapture); + + manager.add(new Action("SYSTEM_TIME_THREAD", Action.AS_DROP_DOWN_MENU) + { + @Override + public void run() + { + final String[] timeModes = { + "SYSTEM_TIME_REALTIME", "SYSTEM_TIME_MONOTONIC", "SYSTEM_TIME_PROCESS", + "SYSTEM_TIME_THREAD" + }; + int i = java.util.Arrays.asList(timeModes).indexOf(this.getText()); + i = (i + 1) % timeModes.length; + DebuggerMessage.Message.Builder builder = DebuggerMessage.Message.newBuilder(); + builder.setContextId(0); // FIXME: proper context id + builder.setType(Type.Response); + builder.setExpectResponse(false); + builder.setFunction(DebuggerMessage.Message.Function.SETPROP); + builder.setProp(Prop.TimeMode); + builder.setArg0(i); + messageQueue.AddCommand(builder.build()); + this.setText(timeModes[i]); + manager.update(true); + } + }); + } + + private void ConnectDisconnect() { + if (!running) { + running = true; + messageQueue.Start(); + thread = new Thread(this); + thread.start(); + actionConnect.setText("Disconnect"); + actionConnect.setToolTipText("Disconnect from debuggee"); + } else { + running = false; + messageQueue.Stop(); + actionConnect.setText("Connect"); + actionConnect.setToolTipText("Connect to debuggee"); + } + this.getSite().getShell().getDisplay().syncExec(new Runnable() { + @Override + public void run() { + getViewSite().getActionBars().getToolBarManager().update(true); + } + }); + } + + private void makeActions() { + actionConnect = new Action() { + @Override + public void run() { + ConnectDisconnect(); + } + }; + actionConnect.setText("Connect"); + actionConnect.setToolTipText("Connect to debuggee"); + // action1.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages() + // .getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + + doubleClickAction = new Action() { + @Override + public void run() { + IStructuredSelection selection = (IStructuredSelection) viewer + .getSelection(); + MessageData msgData = (MessageData) selection.getFirstElement(); + if (null != msgData.shader) + showMessage(msgData.shader); + else if (null != msgData.data) + { + String str = ""; + for (int i = 0; i < msgData.data.length; i++) + { + str += str.format("%.2f", msgData.data[i]); + if (i < msgData.data.length - 1) + str += ", "; + } + showMessage(str); + } + else + showMessage(msgData.columns[3].toString()); + } + }; + } + + private void hookDoubleClickAction() { + viewer.addDoubleClickListener(new IDoubleClickListener() { + @Override + public void doubleClick(DoubleClickEvent event) { + doubleClickAction.run(); + } + }); + } + + private void hookSelectionChanged() { + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + StructuredSelection selection = (StructuredSelection) event + .getSelection(); + if (null == selection) + return; + if (1 != selection.size()) + return; + MessageData msgData = (MessageData) selection.getFirstElement(); + if (null == msgData) + return; + if (null != msgData.image) + canvas.setBackgroundImage(msgData.image); + } + + }); + } + + private void showMessage(final String message) { + viewer.getControl().getDisplay().syncExec(new Runnable() { + @Override + public void run() { + MessageDialog.openInformation(viewer.getControl().getShell(), + "GL ES 2.0 Debugger Client", message); + } + }); + + } + + public void showError(final Exception e) { + viewer.getControl().getDisplay().syncExec(new Runnable() { + @Override + public void run() { + MessageDialog.openError(viewer.getControl().getShell(), + "GL ES 2.0 Debugger Client", e.getMessage()); + } + }); + + } + + /** + * Passing the focus request to the viewer's control. + */ + @Override + public void setFocus() { + viewer.getControl().setFocus(); + } + + @Override + public void run() { + boolean refresh = false; + ArrayList msgs = new ArrayList(); + while (running) { + if (!messageQueue.IsRunning()) + break; + + DebuggerMessage.Message msg = messageQueue.RemoveMessage(0); + if (msgs.size() > 20) { + viewContentProvider.add(msgs); + msgs.clear(); + } + if (null == msg) { + try { + Thread.sleep(1); + continue; + } catch (InterruptedException e) { + showError(e); + } + } + final MessageData msgData = new MessageData(this.getViewSite() + .getShell().getDisplay(), msg); + msgs.add(msgData); + } + if (running) + ConnectDisconnect(); // error occurred, disconnect + } +} From 8b2eabd60deaaa1c8198dacba382f793503bed2b Mon Sep 17 00:00:00 2001 From: David Li Date: Tue, 8 Mar 2011 16:57:24 -0800 Subject: [PATCH 2/2] Added state tracking and vertex data capturing. Change-Id: I91604740aa73a5611f0eb511d02f09a767273700 Signed-off-by: David Li --- .../com/android/glesv2debugger/Activator.java | 2 + .../glesv2debugger/GLServerVertex.java | 348 ++++++++++++++++++ .../android/glesv2debugger/MessageData.java | 26 +- .../glesv2debugger/MessageProcessor.java | 28 +- .../android/glesv2debugger/MessageQueue.java | 196 +++++++--- .../android/glesv2debugger/SampleView.java | 90 ++++- 6 files changed, 610 insertions(+), 80 deletions(-) create mode 100644 tools/glesv2debugger/src/com/android/glesv2debugger/GLServerVertex.java diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java b/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java index f859510d5..6083c0f9c 100755 --- a/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/Activator.java @@ -43,6 +43,7 @@ public class Activator extends AbstractUIPlugin { * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext * ) */ + @Override public void start(BundleContext context) throws Exception { super.start(context); plugin = this; @@ -54,6 +55,7 @@ public class Activator extends AbstractUIPlugin { * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext * ) */ + @Override public void stop(BundleContext context) throws Exception { plugin = null; super.stop(context); diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/GLServerVertex.java b/tools/glesv2debugger/src/com/android/glesv2debugger/GLServerVertex.java new file mode 100644 index 000000000..0ff03475b --- /dev/null +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/GLServerVertex.java @@ -0,0 +1,348 @@ +/* + ** 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. + */ + +package com.android.glesv2debugger; + +import com.android.glesv2debugger.DebuggerMessage.Message; + +import java.nio.ByteBuffer; +import java.util.HashMap; + +class GLBuffer { + GLEnum usage; + GLEnum target; + ByteBuffer data; +} + +class GLAttribPointer { + int size; // number of values per vertex + GLEnum type; // data type + int stride; // bytes + int ptr; // pointer in debugger server or byte offset into buffer + GLBuffer buffer; + boolean normalized; + boolean enabled; +} + +public class GLServerVertex { + + HashMap buffers; + GLBuffer attribBuffer, indexBuffer; // current binding + GLAttribPointer attribPointers[]; + float defaultAttribs[][]; + int maxAttrib; + + public GLServerVertex() { + buffers = new HashMap(); + buffers.put(0, null); + attribPointers = new GLAttribPointer[16]; + for (int i = 0; i < attribPointers.length; i++) + attribPointers[i] = new GLAttribPointer(); + defaultAttribs = new float[16][4]; + for (int i = 0; i < defaultAttribs.length; i++) { + defaultAttribs[i][0] = 0; + defaultAttribs[i][1] = 0; + defaultAttribs[i][2] = 0; + defaultAttribs[i][3] = 1; + } + } + + // void API_ENTRY(glBindBuffer)(GLenum target, GLuint buffer) + public void glBindBuffer(Message msg) { + if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ARRAY_BUFFER) { + attribBuffer = buffers.get(msg.getArg1()); + if (null != attribBuffer) + attribBuffer.target = GLEnum.GL_ARRAY_BUFFER; + } else if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { + indexBuffer = buffers.get(msg.getArg1()); + if (null != indexBuffer) + indexBuffer.target = GLEnum.GL_ELEMENT_ARRAY_BUFFER; + } else + assert false; + } + + // void API_ENTRY(glBufferData)(GLenum target, GLsizeiptr size, const + // GLvoid:size:in data, GLenum usage) + public void glBufferData(Message msg) { + if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ARRAY_BUFFER) { + attribBuffer.usage = GLEnum.valueOf(msg.getArg3()); + attribBuffer.data = msg.getData().asReadOnlyByteBuffer(); + } else if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { + indexBuffer.usage = GLEnum.valueOf(msg.getArg3()); + indexBuffer.data = msg.getData().asReadOnlyByteBuffer(); + } else + assert false; + } + + // void API_ENTRY(glBufferSubData)(GLenum target, GLintptr offset, + // GLsizeiptr size, const GLvoid:size:in data) + public void glBufferSubData(Message msg) { + if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ARRAY_BUFFER) { + if (attribBuffer.data.isReadOnly()) { + ByteBuffer buffer = ByteBuffer.allocate(attribBuffer.data.capacity()); + buffer.put(attribBuffer.data); + attribBuffer.data = buffer; + } + attribBuffer.data.position(msg.getArg1()); + attribBuffer.data.put(msg.getData().asReadOnlyByteBuffer()); + } else if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { + if (indexBuffer.data.isReadOnly()) { + ByteBuffer buffer = ByteBuffer.allocate(indexBuffer.data.capacity()); + buffer.put(indexBuffer.data); + indexBuffer.data = buffer; + } + indexBuffer.data.position(msg.getArg1()); + indexBuffer.data.put(msg.getData().asReadOnlyByteBuffer()); + } else + assert false; + } + + // void glDeleteBuffers(GLsizei n, const GLuint* buffers) + public void glDeleteBuffers(Message msg) { + final int n = msg.getArg0(); + final ByteBuffer names = msg.getData().asReadOnlyByteBuffer(); + for (int i = 0; i < n; i++) { + int name = Integer.reverseBytes(names.getInt()); + GLBuffer buffer = buffers.get(name); + for (int j = 0; j < attribPointers.length; j++) + if (attribPointers[j].buffer == buffer) { + attribPointers[j].buffer = null; + attribPointers[j].enabled = false; + } + if (attribBuffer == buffer) + attribBuffer = null; + if (indexBuffer == buffer) + indexBuffer = null; + buffers.remove(name); + } + } + + // void glDisableVertexAttribArray(GLuint index) + public void glDisableVertexAttribArray(Message msg) { + attribPointers[msg.getArg0()].enabled = false; + } + + float FetchConvert(final ByteBuffer src, final GLEnum type, final boolean normalized) { + if (GLEnum.GL_FLOAT == type) + return Float.intBitsToFloat(Integer.reverseBytes(src.getInt())); + else if (GLEnum.GL_UNSIGNED_INT == type) + if (normalized) + return (Integer.reverseBytes(src.getInt()) & 0xffffffffL) / (2e32f - 1); + else + return Integer.reverseBytes(src.getInt()) & 0xffffffffL; + else if (GLEnum.GL_INT == type) + if (normalized) + return (Integer.reverseBytes(src.getInt()) * 2 + 1) / (2e32f - 1); + else + return Integer.reverseBytes(src.getInt()); + else if (GLEnum.GL_UNSIGNED_SHORT == type) + if (normalized) + return (Short.reverseBytes(src.getShort()) & 0xffff) / (2e16f - 1); + else + return Short.reverseBytes(src.getShort()) & 0xffff; + else if (GLEnum.GL_SHORT == type) + if (normalized) + return (Short.reverseBytes(src.getShort()) * 2 + 1) / (2e16f - 1); + else + return Short.reverseBytes(src.getShort()); + else if (GLEnum.GL_UNSIGNED_BYTE == type) + if (normalized) + return (src.get() & 0xff) / (2e8f - 1); + else + return src.get() & 0xff; + else if (GLEnum.GL_BYTE == type) + if (normalized) + return (src.get() * 2 + 1) / (2e8f - 1); + else + return src.get(); + else if (GLEnum.GL_FIXED == type) + if (normalized) + return (Integer.reverseBytes(src.getInt()) * 2 + 1) / (2e32f - 1); + else + return Integer.reverseBytes(src.getInt()) / (2e16f); + else + assert false; + return 0; + } + + void Fetch(int index, final ByteBuffer nonVBO, final ByteBuffer dst) { + for (int i = 0; i < maxAttrib; i++) { + final GLAttribPointer attrib = attribPointers[i]; + int size = 0; + if (attrib.enabled) + size = attrib.size; + if (null != attrib.buffer) { + final ByteBuffer src = attrib.buffer.data; + src.position(attrib.ptr + i * attrib.stride); + dst.putFloat(FetchConvert(src, attrib.type, attrib.normalized)); + } else + for (int j = 0; j < size; j++) + dst.putFloat(FetchConvert(nonVBO, attrib.type, attrib.normalized)); + if (size < 1) + dst.putFloat(defaultAttribs[i][0]); + if (size < 2) + dst.putFloat(defaultAttribs[i][1]); + if (size < 3) + dst.putFloat(defaultAttribs[i][2]); + if (size < 4) + dst.putFloat(defaultAttribs[i][3]); + } + } + + // void glDrawArrays(GLenum mode, GLint first, GLsizei count) + public Message glDrawArrays(Message msg) { + maxAttrib = msg.getArg7(); + final int first = msg.getArg1(), count = msg.getArg2(); + final ByteBuffer buffer = ByteBuffer.allocate(4 * 4 * maxAttrib * count); + ByteBuffer arrays = null; + if (msg.hasData()) // server sends user pointer attribs + arrays = msg.getData().asReadOnlyByteBuffer(); + for (int i = first; i < first + count; i++) + Fetch(i, arrays, buffer); + assert null == arrays || arrays.remaining() == 0; + buffer.rewind(); + return msg.toBuilder().setData(com.google.protobuf.ByteString.copyFrom(buffer)) + .setArg8(GLEnum.GL_FLOAT.value).build(); + } + + // void glDrawElements(GLenum mode, GLsizei count, GLenum type, const + // GLvoid* indices) + public Message glDrawElements(Message msg) { + maxAttrib = msg.getArg7(); + final int count = msg.getArg1(); + final GLEnum type = GLEnum.valueOf(msg.getArg2()); + final ByteBuffer buffer = ByteBuffer.allocate(4 * 4 * maxAttrib * count); + ByteBuffer arrays = null, index = null; + if (msg.hasData()) // server sends user pointer attribs + arrays = msg.getData().asReadOnlyByteBuffer(); + if (null == indexBuffer) + index = arrays; // server also interleaves user pointer indices + else { + index = indexBuffer.data; + index.position(msg.getArg3()); + } + if (GLEnum.GL_UNSIGNED_SHORT == type) + for (int i = 0; i < count; i++) + Fetch(Short.reverseBytes(index.getShort()) & 0xffff, arrays, buffer); + else if (GLEnum.GL_UNSIGNED_BYTE == type) + for (int i = 0; i < count; i++) + Fetch(index.get() & 0xff, arrays, buffer); + else + assert false; + assert null == arrays || arrays.remaining() == 0; + buffer.rewind(); + return msg.toBuilder().setData(com.google.protobuf.ByteString.copyFrom(buffer)) + .setArg8(GLEnum.GL_FLOAT.value).build(); + } + + // void glEnableVertexAttribArray(GLuint index) + public void glEnableVertexAttribArray(Message msg) { + attribPointers[msg.getArg0()].enabled = true; + } + + // void API_ENTRY(glGenBuffers)(GLsizei n, GLuint:n:out buffers) + public void glGenBuffers(Message msg) { + final int n = msg.getArg0(); + final ByteBuffer buffer = msg.getData().asReadOnlyByteBuffer(); + for (int i = 0; i < n; i++) { + int name = Integer.reverseBytes(buffer.getInt()); + if (!buffers.containsKey(name)) + buffers.put(name, new GLBuffer()); + } + } + + // void glVertexAttribPointer(GLuint index, GLint size, GLenum type, + // GLboolean normalized, GLsizei stride, const GLvoid* ptr) + public void glVertexAttribPointer(Message msg) { + GLAttribPointer attrib = attribPointers[msg.getArg0()]; + attrib.size = msg.getArg1(); + attrib.type = GLEnum.valueOf(msg.getArg2()); + attrib.normalized = msg.getArg3() != 0; + attrib.stride = msg.getArg4(); + if (0 == attrib.stride) + attrib.stride = attrib.size * 4; + attrib.ptr = msg.getArg5(); + attrib.buffer = attribBuffer; + } + + // void glVertexAttrib1f(GLuint indx, GLfloat x) + public void glVertexAttrib1f(Message msg) { + glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(Integer.reverseBytes(msg.getArg1())), + 0, 0, 1); + } + + // void glVertexAttrib1fv(GLuint indx, const GLfloat* values) + public void glVertexAttrib1fv(Message msg) { + final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); + glVertexAttrib4f(msg.getArg0(), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + 0, 0, 1); + } + + // void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) + public void glVertexAttrib2f(Message msg) { + glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(Integer.reverseBytes(msg.getArg1())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg2())), 0, 1); + } + + // void glVertexAttrib2fv(GLuint indx, const GLfloat* values) + public void glVertexAttrib2fv(Message msg) { + final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); + glVertexAttrib4f(msg.getArg0(), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), 0, 1); + } + + // void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) + public void glVertexAttrib3f(Message msg) { + glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(Integer.reverseBytes(msg.getArg1())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg2())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg3())), 1); + } + + // void glVertexAttrib3fv(GLuint indx, const GLfloat* values) + public void glVertexAttrib3fv(Message msg) { + final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); + glVertexAttrib4f(msg.getArg0(), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), 1); + } + + public void glVertexAttrib4f(Message msg) { + glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(Integer.reverseBytes(msg.getArg1())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg2())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg3())), + Float.intBitsToFloat(Integer.reverseBytes(msg.getArg4()))); + } + + void glVertexAttrib4f(int indx, float x, float y, float z, float w) { + defaultAttribs[indx][0] = x; + defaultAttribs[indx][1] = y; + defaultAttribs[indx][2] = z; + defaultAttribs[indx][3] = w; + } + + // void glVertexAttrib4fv(GLuint indx, const GLfloat* values) + public void glVertexAttrib4fv(Message msg) { + final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); + glVertexAttrib4f(msg.getArg0(), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt())), + Float.intBitsToFloat(Integer.reverseBytes(values.getInt()))); + } +} diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java index 729592e70..110c6f8b9 100644 --- a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageData.java @@ -25,8 +25,10 @@ public class MessageData { public Image image; // texture public String shader; // shader source public String[] columns; - public float[] data; // vertex attributes - + public float[] data; + public int maxAttrib; // used for formatting data + public GLEnum dataType; // could be float, int; mainly for formatting use + public MessageData(final Device device, final DebuggerMessage.Message msg) { image = null; shader = null; @@ -46,11 +48,13 @@ public class MessageData { columns[2] = Integer.toHexString(msg.getContextId()); columns[3] = MessageFormatter.Format(msg); switch (function) { - case glBufferData: - data = MessageProcessor.ReceiveData(msg.getArg0(), msg.getData()); - break; - case glBufferSubData: - data = MessageProcessor.ReceiveData(msg.getArg0(), msg.getData()); + case glDrawArrays: // msg was modified by GLServerVertex + case glDrawElements: + if (!msg.hasArg8() || !msg.hasData()) + break; + dataType = GLEnum.valueOf(msg.getArg8()); + maxAttrib = msg.getArg7(); + data = MessageProcessor.ReceiveData(dataType, msg.getData()); break; case glShaderSource: shader = msg.getData().toStringUtf8(); @@ -76,6 +80,14 @@ public class MessageData { break; image = new Image(device, imageData); break; + case glCopyTexImage2D: + imageData = MessageProcessor.ReceiveImage(msg.getArg5(), msg.getArg6(), GLEnum.GL_RGBA.value, GLEnum.GL_UNSIGNED_BYTE.value, msg.getData().toByteArray()); + image = new Image(device, imageData); + break; + case glCopyTexSubImage2D: + imageData = MessageProcessor.ReceiveImage(msg.getArg6(), msg.getArg7(), GLEnum.GL_RGBA.value, GLEnum.GL_UNSIGNED_BYTE.value, msg.getData().toByteArray()); + image = new Image(device, imageData); + break; case glReadPixels: if (!msg.hasData()) break; diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java index 0c4a0053a..da6a9b839 100644 --- a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageProcessor.java @@ -126,23 +126,25 @@ public class MessageProcessor { return new ImageData(width, height, bpp, palette, 1, data); } - static public float[] ReceiveData(int target, final ByteString data) { - ByteBuffer buffer = data.asReadOnlyByteBuffer(); - GLEnum type = GLEnum.valueOf(target); - if (type == GLEnum.GL_ARRAY_BUFFER) { + static public float[] ReceiveData(final GLEnum type, final ByteString data) { + final ByteBuffer buffer = data.asReadOnlyByteBuffer(); + if (type == GLEnum.GL_FLOAT) { float[] elements = new float[buffer.remaining() / 4]; - buffer.asFloatBuffer().get(elements); + for (int i = 0; i < elements.length; i++) + elements[i] = buffer.getFloat(); return elements; - } else if (type == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { - // usually unsigned short + } else if (type == GLEnum.GL_UNSIGNED_SHORT) { float[] elements = new float[buffer.remaining() / 2]; - for (int i = 0; i < elements.length; i++) { - int bits = Short.reverseBytes(buffer.getShort()) & 0xffff; - elements[i] = bits; - } + for (int i = 0; i < elements.length; i++) + elements[i] = buffer.getShort() & 0xffff; + return elements; + } else if (type == GLEnum.GL_UNSIGNED_BYTE) { + float[] elements = new float[buffer.remaining() / 4]; + for (int i = 0; i < elements.length; i++) + elements[i] = buffer.get() & 0xff; return elements; } else - return null; - + assert false; + return null; } } diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java index 9f91d404b..afa7e91ea 100644 --- a/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/MessageQueue.java @@ -16,13 +16,12 @@ package com.android.glesv2debugger; -import com.android.glesv2debugger.DebuggerMessage.Message.Function; import com.android.glesv2debugger.DebuggerMessage.Message.Type; -import java.io.EOFException; -import java.io.IOException; import java.io.DataInputStream; import java.io.DataOutputStream; +import java.io.EOFException; +import java.io.IOException; import java.net.Socket; import java.util.ArrayList; import java.util.HashMap; @@ -35,6 +34,8 @@ public class MessageQueue implements Runnable { ArrayList commands = new ArrayList(); SampleView sampleView; + HashMap serversVertex = new HashMap(); + public MessageQueue(SampleView sampleView) { this.sampleView = sampleView; } @@ -95,19 +96,20 @@ public class MessageQueue implements Runnable { Error(e); } - try { - while (running) { - DebuggerMessage.Message msg = null; - if (incoming.size() > 0) { // find queued incoming - for (ArrayList messages : incoming + // try { + while (running) { + DebuggerMessage.Message msg = null; + if (incoming.size() > 0) { // find queued incoming + for (ArrayList messages : incoming .values()) - if (messages.size() > 0) { - msg = messages.get(0); - messages.remove(0); - break; - } - } - if (null == msg) { // get incoming from network + if (messages.size() > 0) { + msg = messages.get(0); + messages.remove(0); + break; + } + } + if (null == msg) { // get incoming from network + try { msg = ReadMessage(dis); if (msg.getExpectResponse()) { if (msg.getType() == Type.BeforeCall) @@ -119,28 +121,34 @@ public class MessageQueue implements Runnable { // SendResponse(dos, msg.getContextId(), // DebuggerMessage.Message.Function.SKIP); else if (msg.getType() == Type.Response) - ; + assert true; else assert false; } + } catch (IOException e) { + Error(e); + running = false; + break; } + } - int contextId = msg.getContextId(); - if (!incoming.containsKey(contextId)) - incoming.put(contextId, + int contextId = msg.getContextId(); + if (!incoming.containsKey(contextId)) + incoming.put(contextId, new ArrayList()); - // FIXME: the expected sequence will change for interactive mode - while (msg.getType() == Type.BeforeCall) { - DebuggerMessage.Message next = null; - // get existing message part for this context - ArrayList messages = incoming + // FIXME: the expected sequence will change for interactive mode + while (msg.getType() == Type.BeforeCall) { + DebuggerMessage.Message next = null; + // get existing message part for this context + ArrayList messages = incoming .get(contextId); - if (messages.size() > 0) { - next = messages.get(0); - messages.remove(0); - } - if (null == next) { // read new part for message + if (messages.size() > 0) { + next = messages.get(0); + messages.remove(0); + } + if (null == next) { // read new part for message + try { next = ReadMessage(dis); if (next.getExpectResponse()) { @@ -150,45 +158,123 @@ public class MessageQueue implements Runnable { next.getContextId(), DebuggerMessage.Message.Function.CONTINUE); else if (next.getType() == Type.AfterCall) - SendCommands(dos, 0); // FIXME: proper context id + SendCommands(dos, 0); // FIXME: proper context + // id else if (msg.getType() == Type.Response) - ; + assert true; else assert false; } - - if (next.getContextId() != contextId) { - // message part not for this context - if (!incoming.containsKey(next.getContextId())) - incoming.put( - next.getContextId(), - new ArrayList()); - incoming.get(next.getContextId()).add(next); - continue; - } + } catch (IOException e) { + Error(e); + running = false; + break; } - DebuggerMessage.Message.Builder builder = msg.toBuilder(); - // builder.mergeFrom(next); seems to merge incorrectly - if (next.hasRet()) - builder.setRet(next.getRet()); - if (next.hasTime()) - builder.setTime(next.getTime()); - if (next.hasData()) - builder.setData(next.getData()); - builder.setType(next.getType()); - msg = builder.build(); + if (next.getContextId() != contextId) { + // message part not for this context + if (!incoming.containsKey(next.getContextId())) + incoming.put( + next.getContextId(), + new ArrayList()); + incoming.get(next.getContextId()).add(next); + continue; + } } - synchronized (complete) { - complete.add(msg); - } + DebuggerMessage.Message.Builder builder = msg.toBuilder(); + // builder.mergeFrom(next); seems to merge incorrectly + if (next.hasRet()) + builder.setRet(next.getRet()); + if (next.hasTime()) + builder.setTime(next.getTime()); + if (next.hasData()) + builder.setData(next.getData()); + builder.setType(next.getType()); + msg = builder.build(); } + + GLServerVertex serverVertex = serversVertex.get(msg.getContextId()); + if (null == serverVertex) { + serverVertex = new GLServerVertex(); + serversVertex.put(msg.getContextId(), serverVertex); + } + + // forward message to synchronize state + switch (msg.getFunction()) { + case glBindBuffer: + serverVertex.glBindBuffer(msg); + break; + case glBufferData: + serverVertex.glBufferData(msg); + break; + case glBufferSubData: + serverVertex.glBufferSubData(msg); + break; + case glDeleteBuffers: + serverVertex.glDeleteBuffers(msg); + break; + case glDrawArrays: + if (msg.hasArg7()) + msg = serverVertex.glDrawArrays(msg); + break; + case glDrawElements: + if (msg.hasArg7()) + msg = serverVertex.glDrawElements(msg); + break; + case glDisableVertexAttribArray: + serverVertex.glDisableVertexAttribArray(msg); + break; + case glEnableVertexAttribArray: + serverVertex.glEnableVertexAttribArray(msg); + break; + case glGenBuffers: + serverVertex.glGenBuffers(msg); + break; + case glVertexAttribPointer: + serverVertex.glVertexAttribPointer(msg); + break; + case glVertexAttrib1f: + serverVertex.glVertexAttrib1f(msg); + break; + case glVertexAttrib1fv: + serverVertex.glVertexAttrib1fv(msg); + break; + case glVertexAttrib2f: + serverVertex.glVertexAttrib2f(msg); + break; + case glVertexAttrib2fv: + serverVertex.glVertexAttrib2fv(msg); + break; + case glVertexAttrib3f: + serverVertex.glVertexAttrib3f(msg); + break; + case glVertexAttrib3fv: + serverVertex.glVertexAttrib3fv(msg); + break; + case glVertexAttrib4f: + serverVertex.glVertexAttrib4f(msg); + break; + case glVertexAttrib4fv: + serverVertex.glVertexAttrib4fv(msg); + break; + } + + synchronized (complete) { + complete.add(msg); + } + } + + try { socket.close(); - } catch (Exception e) { + } catch (IOException e) { Error(e); running = false; } + // } catch (Exception e) { + // Error(e); + // running = false; + // } } public DebuggerMessage.Message RemoveMessage(int contextId) { diff --git a/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java b/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java index 05fe51bbd..41a0bb2b9 100755 --- a/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java +++ b/tools/glesv2debugger/src/com/android/glesv2debugger/SampleView.java @@ -42,13 +42,16 @@ import org.eclipse.jface.viewers.TableViewer; import org.eclipse.jface.viewers.Viewer; import org.eclipse.jface.viewers.ViewerFilter; import org.eclipse.jface.viewers.ViewerSorter; +import org.eclipse.jface.window.Window; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Menu; @@ -56,6 +59,7 @@ import org.eclipse.swt.widgets.ScrollBar; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Table; import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.Text; import org.eclipse.ui.IActionBars; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.IWorkbenchActionConstants; @@ -92,6 +96,7 @@ public class SampleView extends ViewPart implements Runnable { TableViewer viewer; org.eclipse.swt.widgets.Canvas canvas; + Text text; Action actionConnect; // connect / disconnect Action doubleClickAction; Action actionAutoScroll; @@ -131,7 +136,6 @@ public class SampleView extends ViewPart implements Runnable { @Override public void inputChanged(Viewer v, Object oldInput, Object newInput) { - // showMessage("ViewContentProvider::inputChanged"); } @Override @@ -251,8 +255,35 @@ public class SampleView extends ViewPart implements Runnable { hookSelectionChanged(); contributeToActionBars(); - canvas = new Canvas(parent, SWT.NO_BACKGROUND | SWT.NO_REDRAW_RESIZE + class LayoutComposite extends Composite { + public LayoutComposite(Composite parent, int style) { + super(parent, style); + } + + @Override + public Control[] getChildren() { + Control[] children = super.getChildren(); + ArrayList controls = new ArrayList(); + for (int i = 0; i < children.length; i++) + if (children[i].isVisible()) + controls.add(children[i]); + children = new Control[controls.size()]; + return controls.toArray(children); + } + + } + + LayoutComposite layoutComposite = new LayoutComposite(parent, 0); + layoutComposite.setLayout(new FillLayout()); + + text = new Text(layoutComposite, SWT.NO_BACKGROUND | SWT.READ_ONLY | SWT.V_SCROLL | SWT.H_SCROLL); + text.setVisible(false); + + canvas = new Canvas(layoutComposite, SWT.NO_BACKGROUND | SWT.NO_REDRAW_RESIZE + | SWT.V_SCROLL | SWT.H_SCROLL); + canvas.setVisible(false); + final ScrollBar hBar = canvas.getHorizontalBar(); hBar.addListener(SWT.Selection, new Listener() { @Override @@ -383,7 +414,7 @@ public class SampleView extends ViewPart implements Runnable { shell, "Contains Filter", "case sensitive substring or *", actionFilter.getText(), null); - if (dialog.OK == dialog.open()) { + if (Window.OK == dialog.open()) { actionFilter.setText(dialog.getValue()); manager.update(true); filters = dialog.getValue().split("\\|"); @@ -485,9 +516,13 @@ public class SampleView extends ViewPart implements Runnable { String str = ""; for (int i = 0; i < msgData.data.length; i++) { - str += str.format("%.2f", msgData.data[i]); + str += String.format("%f", msgData.data[i]); + if (i % (4 * msgData.maxAttrib) == (4 * msgData.maxAttrib - 1)) + str += '\n'; + else if (i % 4 == 3) + str += " -"; if (i < msgData.data.length - 1) - str += ", "; + str += ' '; } showMessage(str); } @@ -515,12 +550,57 @@ public class SampleView extends ViewPart implements Runnable { if (null == selection) return; if (1 != selection.size()) + { + Object[] objects = selection.toArray(); + float totalTime = 0; + for (int i = 0; i < objects.length; i++) + { + MessageData msgData = (MessageData) objects[i]; + if (null == msgData) + continue; + totalTime += Float.parseFloat(msgData.columns[1]); + } + viewer.getTable().getColumn(1).setText(Float.toString(totalTime)); return; + } + else + viewer.getTable().getColumn(1).setText("Elapsed (ms)"); MessageData msgData = (MessageData) selection.getFirstElement(); if (null == msgData) return; if (null != msgData.image) + { + text.setVisible(false); + canvas.setVisible(true); canvas.setBackgroundImage(msgData.image); + canvas.getParent().layout(); + } + else if (null != msgData.shader) + { + text.setText(msgData.shader); + text.setVisible(true); + canvas.setVisible(false); + text.getParent().layout(); + } + else if (null != msgData.data) + { + String str = ""; + for (int i = 0; i < msgData.data.length; i++) + { + str += String.format("%.3g", msgData.data[i]); + if (i % (4 * msgData.maxAttrib) == (4 * msgData.maxAttrib - 1)) + str += '\n'; + else if (i % 4 == 3) + str += " -"; + if (i < msgData.data.length - 1) + str += ' '; + } + + text.setText(str); + text.setVisible(true); + canvas.setVisible(false); + text.getParent().layout(); + } } });