/*
** 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 com.android.glesv2debugger.DebuggerMessage.Message.Function;
import com.android.sdklib.util.SparseIntArray;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.widgets.Shell;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
public class CodeGen implements IRunnableWithProgress {
private FileWriter codeFile, makeFile, namesHeaderFile, namesSourceFile;
private PrintWriter code, make, namesHeader, namesSource;
private FileOutputStream dataOut;
private SparseIntArray bufferNames,
framebufferNames, programNames, textureNames, shaderNames, renderbufferNames;
/** return true if msg was a texture upload */
private boolean codeGenTextureUpload(final Message msg, final boolean replaceCopy) {
String s = null;
switch (msg.getFunction()) {
case glCompressedTexImage2D:
s = MessageFormatter.format(msg, true).replace("arg7", "texData");
break;
case glCompressedTexSubImage2D:
case glTexImage2D:
case glTexSubImage2D:
s = MessageFormatter.format(msg, true).replace("arg8", "texData");
break;
case glCopyTexImage2D:
if (!replaceCopy) {
code.write(MessageFormatter.format(msg, true));
code.write(";CHKERR;\n");
return true;
}
assert msg.getArg2() == msg.getPixelFormat(); // TODO
s = "//" + MessageFormatter.format(msg, true) + "\n";
s += String.format("glTexImage2D(%s, %d, %s, %d, %d, %d, %s, %s, texData);CHKERR;",
GLEnum.valueOf(msg.getArg0()), msg.getArg1(),
GLEnum.valueOf(msg.getArg2()), msg.getArg5(), msg.getArg6(),
msg.getArg7(), GLEnum.valueOf(msg.getPixelFormat()),
GLEnum.valueOf(msg.getPixelType()));
break;
case glCopyTexSubImage2D:
if (!replaceCopy) {
code.write(MessageFormatter.format(msg, true));
code.write(";CHKERR;\n");
return true;
}
// FIXME: check the texture format & type, and convert
s = "//" + MessageFormatter.format(msg, true) + "\n";
s += String.format(
"glTexSubImage2D(%s, %d, %d, %d, %d, %d, %s, %s, texData);CHKERR;",
GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(),
msg.getArg3(), msg.getArg6(), msg.getArg7(),
GLEnum.valueOf(msg.getPixelFormat()), GLEnum.valueOf(msg.getPixelType()));
break;
default:
return false;
}
if (msg.hasData()) {
final byte[] data = MessageProcessor.lzfDecompressChunks(msg.getData());
try {
code.write("{\n");
code.format(" void * texData = malloc(%d);CHKERR;\n", data.length);
code.format(" FILE * texFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n");
code.format(" assert(texFile);CHKERR;\n");
code.format(" fseek(texFile, %d, SEEK_SET);CHKERR;\n", dataOut.getChannel()
.position());
dataOut.write(data);
code.format(" fread(texData, %d, 1, texFile);CHKERR;\n", data.length);
code.format(" fclose(texFile);CHKERR;\n");
code.format(" " + s + ";\n");
code.format(" free(texData);CHKERR;\n");
code.format("}\n");
} catch (IOException e) {
e.printStackTrace();
assert false;
}
} else
code.write(s.replace("texData", "NULL") + ";\n");
return true;
}
private void codeGenServerState(final GLServerState serverState) {
code.write("// CodeGenServerState\n");
for (int i = 0; i < serverState.enableDisables.size(); i++) {
final GLEnum key = GLEnum.valueOf(serverState.enableDisables.keyAt(i));
if (serverState.enableDisables.valueAt(i) == 0)
code.format("glDisable(%s);CHKERR;\n", key);
else
code.format("glEnable(%s);CHKERR;\n", key);
}
for (int i = 0; i < serverState.lastSetter.size(); i++) {
final Function key = Function.valueOf(serverState.lastSetter.keyAt(i));
final Message msg = serverState.lastSetter.valueAt(i);
if (msg == null) {
code.format("// %s is default\n", key);
continue;
}
final String s = MessageFormatter.format(msg, true);
code.write(s);
code.write(";\n");
}
// TODO: stencil and integers
}
private void codeGenServerShader(final GLServerShader serverShader) {
code.write("// CodeGenServerShader\n");
for (int i = 0; i < serverShader.shaders.size(); i++) {
final int name = serverShader.shaders.keyAt(i);
final GLShader shader = serverShader.shaders.valueAt(i);
final String id = "shader_" + name;
if (shaderNames.indexOfKey(name) < 0) {
namesSource.format("GLuint %s = 0;\n", id);
namesHeader.format("extern GLuint %s;\n", id);
}
code.format("%s = glCreateShader(%s);CHKERR;\n", id, shader.type);
shaderNames.put(name, name);
if (shader.source != null) {
final String src = shader.source.replace("\r", "").replace("\n", "\\n\\\n")
.replace("\"", "\\\"");
code.format("glShaderSource(%s, 1, (const GLchar *[]){\"%s\"}, NULL);CHKERR;\n",
id, src);
code.format("glCompileShader(%s);CHKERR;\n", id);
}
}
for (int i = 0; i < serverShader.programs.size(); i++) {
final int name = serverShader.programs.keyAt(i);
final GLProgram program = serverShader.programs.valueAt(i);
final String id = "program_" + name;
if (programNames.indexOfKey(name) < 0) {
namesSource.format("GLuint %s = 0;\n", id);
namesHeader.format("extern GLuint %s;\n", id);
}
code.format("%s = glCreateProgram();CHKERR;\n", id);
programNames.put(name, name);
code.format("glAttachShader(%s, shader_%d);CHKERR;\n", id,
program.vert);
code.format("glAttachShader(%s, shader_%d);CHKERR;\n", id,
program.frag);
code.format("glLinkProgram(%s);CHKERR;\n", id);
if (serverShader.current == program)
code.format("glUseProgram(%s);CHKERR;\n", id);
}
}
private void codeGenServerTexture(final GLServerTexture serverTexture, final boolean replaceCopy) {
code.write("// CodeGenServerTexture\n");
for (int i = 0; i < serverTexture.textures.size(); i++) {
final int name = serverTexture.textures.keyAt(i);
final GLTexture tex = serverTexture.textures.valueAt(i);
final String id = "texture_" + name;
if (textureNames.indexOfKey(name) < 0) {
namesHeader.format("extern GLuint %s;\n", id);
namesSource.format("GLuint %s = 0;\n", id);
}
code.format("%s = 0;\n", id);
textureNames.put(name, name);
if (name == 0)
continue;
code.format("glGenTextures(1, &%s);CHKERR;\n", id);
String s = String.format("glBindTexture(%s, texture_%d);CHKERR;\n", tex.target,
tex.name);
code.write(s);
for (final Message msg : tex.contentChanges) {
if (codeGenTextureUpload(msg, replaceCopy))
continue;
switch (msg.getFunction()) {
case glGenerateMipmap:
s = MessageFormatter.format(msg, true);
break;
default:
assert false;
}
code.write(s + ";\n");
}
code.format("glTexParameteriv(%s, GL_TEXTURE_WRAP_S, (GLint[]){%s});CHKERR;\n",
tex.target, tex.wrapS);
code.format("glTexParameteriv(%s, GL_TEXTURE_WRAP_T, (GLint[]){%s});CHKERR;\n",
tex.target, tex.wrapT);
code.format("glTexParameteriv(%s, GL_TEXTURE_MIN_FILTER, (GLint[]){%s});CHKERR;\n",
tex.target, tex.min);
code.format("glTexParameteriv(%s, GL_TEXTURE_MAG_FILTER, (GLint[]){%s});CHKERR;\n",
tex.target, tex.mag);
}
for (int i = 0; i < serverTexture.tmu2D.length; i++) {
code.format("glActiveTexture(%s);CHKERR;\n",
GLEnum.valueOf(GLEnum.GL_TEXTURE0.value + i));
code.format("glBindTexture(GL_TEXTURE_2D, texture_%d);CHKERR;\n",
serverTexture.tmu2D[i]);
}
for (int i = 0; i < serverTexture.tmuCube.length; i++) {
code.format("glActiveTexture(%s);CHKERR;\n",
GLEnum.valueOf(GLEnum.GL_TEXTURE0.value + i));
code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, texture_%d);CHKERR;\n",
serverTexture.tmuCube[i]);
}
code.format("glActiveTexture(%s);CHKERR;\n", serverTexture.activeTexture);
if (serverTexture.tex2D == null)
code.format("glBindTexture(GL_TEXTURE_2D, 0);CHKERR;\n");
else
code.format("glBindTexture(GL_TEXTURE_2D, texture_%d);CHKERR;\n",
serverTexture.tex2D.name);
if (serverTexture.texCube == null)
code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHKERR;\n");
else
code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, texture_%d);CHKERR;\n",
serverTexture.texCube.name);
}
private void codeGenBufferData(final ByteBuffer buffer, final String call) {
ByteBuffer bfr = buffer;
if (buffer.isReadOnly()) {
bfr = ByteBuffer.allocate(buffer.capacity());
bfr.put(buffer);
}
final byte[] data = bfr.array();
try {
code.write("{\n");
code.format(" void * bufferData = malloc(%d);\n", data.length);
code.format(" FILE * bufferFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");\n");
code.format(" assert(bufferFile);\n");
code.format(" fseek(bufferFile, %d, SEEK_SET);\n", dataOut.getChannel()
.position());
dataOut.write(data);
code.format(" fread(bufferData, %d, 1, bufferFile);\n", data.length);
code.format(" fclose(bufferFile);\n");
code.format(" " + call + ";CHKERR;\n");
code.format(" free(bufferData);\n");
code.format("}\n");
} catch (IOException e) {
e.printStackTrace();
assert false;
}
}
private void codeGenServerVertex(final GLServerVertex v) {
code.write("// CodeGenServerVertex\n");
for (int i = 0; i < v.buffers.size(); i++) {
final int name = v.buffers.keyAt(i);
final String id = "buffer_" + name;
final GLBuffer buffer = v.buffers.valueAt(i);
if (bufferNames.indexOfKey(name) < 0) {
namesHeader.format("extern GLuint %s;\n", id);
namesSource.format("GLuint %s = 0;\n", id);
}
code.format("%s = 0;\n", id);
bufferNames.put(name, name);
if (name == 0)
continue;
code.format("glGenBuffers(1, &%s);CHKERR;\n", id);
if (buffer.target != null) {
code.format("glBindBuffer(%s, %s);CHKERR;\n", buffer.target, id);
if (buffer.data != null) {
String s = String.format("glBufferData(%s, %d, bufferData, %s)", buffer.target,
buffer.data.capacity(), buffer.usage);
codeGenBufferData(buffer.data, s);
}
}
}
// TODO: use MAX_VERTEX_ATTRIBS
for (int i = 0; i < v.defaultAttribs.length; i++)
code.format("glVertexAttrib4f(%d, %f, %f, %f, %f);CHKERR;\n", i,
v.defaultAttribs[i][0],
v.defaultAttribs[i][1], v.defaultAttribs[i][2], v.defaultAttribs[i][3]);
for (int i = 0; i < v.attribPointers.length; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (att.type == null)
continue;
if (att.buffer != null)
code.format("glBindBuffer(GL_ARRAY_BUFFER, buffer_%d);CHKERR;\n", att.buffer.name);
else
code.format("glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n");
code.format("glVertexAttribPointer(%d, %d, %s, %b, %d, (const GLvoid *)%d);CHKERR;\n",
i, att.size, att.type, att.normalized, att.stride, att.ptr);
}
if (v.attribBuffer != null)
code.format("glBindBuffer(GL_ARRAY_BUFFER, buffer_%d);CHKERR;\n", v.attribBuffer.name);
else
code.write("glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n");
if (v.indexBuffer != null)
code.format("glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_%d);CHKERR;\n",
v.indexBuffer.name);
else
code.write("glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);CHKERR;\n");
}
private void codeGenGenNames(final Message msg) {
final ByteBuffer names = msg.getData().asReadOnlyByteBuffer();
names.order(SampleView.targetByteOrder);
SparseIntArray namesArray = null;
for (int i = 0; i < msg.getArg0(); i++) {
String id = "";
final int name = names.getInt();
switch (msg.getFunction()) {
case glGenBuffers:
id = "buffer";
namesArray = bufferNames;
break;
case glGenFramebuffers:
id = "framebuffer";
namesArray = framebufferNames;
break;
case glGenRenderbuffers:
id = "renderbuffer";
namesArray = renderbufferNames;
break;
case glGenTextures:
id = "texture";
namesArray = textureNames;
break;
default:
assert false;
}
id += "_" + name;
if (namesArray.indexOfKey(name) < 0) {
namesHeader.format("extern GLuint %s;\n", id);
namesSource.format("GLuint %s = 0;\n", id);
}
code.format("%s = 0;\n", id);
namesArray.put(name, name);
code.format("%s(1, &%s);CHKERR;\n", msg.getFunction(), id);
}
}
private void codeGenDeleteNames(final Message msg) {
final ByteBuffer names = msg.getData().asReadOnlyByteBuffer();
names.order(SampleView.targetByteOrder);
SparseIntArray namesArray = null;
for (int i = 0; i < msg.getArg0(); i++) {
String id = null;
final int name = names.getInt();
switch (msg.getFunction()) {
case glDeleteBuffers:
id = "buffer";
namesArray = bufferNames;
break;
case glDeleteFramebuffers:
id = "framebuffer";
namesArray = framebufferNames;
break;
case glDeleteRenderbuffers:
id = "renderbuffer";
namesArray = renderbufferNames;
break;
case glDeleteTextures:
id = "texture";
namesArray = textureNames;
break;
default:
assert false;
}
id += "_" + name;
code.format("%s = 0;\n", id);
namesArray.put(name, 0);
code.format("%s(1, &%s);CHKERR;\n", msg.getFunction(), id);
}
}
private void codeGenBindNames(final Message msg) {
String id = null;
SparseIntArray namesArray = null;
final int name = msg.getArg1();
switch (msg.getFunction()) {
case glBindBuffer:
id = "buffer";
namesArray = bufferNames;
break;
case glBindFramebuffer:
id = "framebuffer";
namesArray = framebufferNames;
break;
case glBindRenderbuffer:
id = "renderbuffer";
namesArray = renderbufferNames;
break;
case glBindTexture:
id = "texture";
namesArray = textureNames;
break;
default:
assert false;
}
id += "_" + name;
if (namesArray.indexOfKey(name) < 0) {
namesHeader.format("extern GLuint %s;\n", id);
namesSource.format("GLuint %s = 0;\n", id);
} else if (namesArray.get(name) != name)
code.format("%s = %d;\n", id, name); // name was deleted
namesArray.put(name, name);
code.write(MessageFormatter.format(msg, true));
code.write(";CHKERR;\n");
}
private void codeGenDrawArrays(final GLServerVertex v, final MessageData msgData)
throws IOException {
final int maxAttrib = msgData.msg.getArg7();
if (maxAttrib < 1) {
code.write("// no vertex data\n");
return;
}
final byte[] data = msgData.msg.getData().toByteArray();
final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0());
final int first = msgData.msg.getArg1(), count = msgData.msg.getArg2();
int attribDataStride = 0;
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
attribDataStride += att.elemSize;
}
assert attribDataStride * count == data.length;
code.write("{\n");
if (attribDataStride > 0) {
code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n");
code.format(" assert(attribFile);CHKERR;\n");
code.format(" fseek(attribFile, %d, SEEK_SET);CHKERR;\n", dataOut.getChannel()
.position());
dataOut.write(data);
code.format(" char * const attribData = (char *)malloc(%d);\n", first
* attribDataStride + data.length);
code.format(" assert(attribData);\n");
code.format(" fread(attribData + %d, %d, 1, attribFile);\n",
first * attribDataStride, data.length);
code.format(" fclose(attribFile);\n");
code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n");
int attribDataOffset = 0;
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
code.format(
" glVertexAttribPointer(%d, %d, %s, %b, %d, attribData + %d);CHKERR;\n",
i, att.size, att.type, att.normalized,
attribDataStride, attribDataOffset);
attribDataOffset += att.elemSize;
}
if (v.attribBuffer != null)
code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n",
v.attribBuffer.name);
}
code.format(" glDrawArrays(%s, %d, %d);CHKERR;\n", mode, first, count);
if (attribDataStride > 0)
code.format(" free(attribData);CHKERR;\n");
code.write("};\n");
}
private void codeGenDrawElements(final GLServerVertex v, final MessageData msgData)
throws IOException {
final int maxAttrib = msgData.msg.getArg7();
if (maxAttrib < 1) {
code.write("// no vertex data\n");
return;
}
final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0());
final int count = msgData.msg.getArg1();
final GLEnum type = GLEnum.valueOf(msgData.msg.getArg2());
String typeName = "GLubyte";
if (type == GLEnum.GL_UNSIGNED_SHORT)
typeName = "GLushort";
int attribDataStride = 0;
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
attribDataStride += att.elemSize;
}
code.write("{\n");
if (v.indexBuffer == null || attribDataStride > 0) {
// need to load user pointer indices and/or attributes
final byte[] element = new byte[attribDataStride];
final ByteBuffer data = msgData.msg.getData().asReadOnlyByteBuffer();
data.order(SampleView.targetByteOrder);
final ByteBuffer indexData = ByteBuffer.allocate(count * GLServerVertex.typeSize(type));
indexData.order(SampleView.targetByteOrder);
final ByteBuffer attribData = ByteBuffer.allocate(count * attribDataStride);
attribData.order(SampleView.targetByteOrder);
int maxIndex = -1;
ByteBuffer indexSrc = data;
if (v.indexBuffer != null) {
indexSrc = v.indexBuffer.data;
indexSrc.position(msgData.msg.getArg3());
}
indexSrc.order(SampleView.targetByteOrder);
for (int i = 0; i < count; i++) {
int index = -1;
if (type == GLEnum.GL_UNSIGNED_BYTE) {
byte idx = indexSrc.get();
index = idx & 0xff;
indexData.put(idx);
} else if (type == GLEnum.GL_UNSIGNED_SHORT) {
short idx = indexSrc.getShort();
index = idx & 0xffff;
indexData.putShort(idx);
} else
assert false;
data.get(element);
attribData.put(element);
if (index > maxIndex)
maxIndex = index;
}
code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n");
code.format(" assert(attribFile);CHKERR;\n");
code.format(" fseek(attribFile, 0x%X, SEEK_SET);CHKERR;\n",
dataOut.getChannel().position());
dataOut.write(indexData.array());
code.format(" %s * const indexData = (%s *)malloc(%d);\n", typeName, typeName,
indexData.capacity());
code.format(" assert(indexData);\n");
code.format(" fread(indexData, %d, 1, attribFile);\n", indexData.capacity());
if (attribDataStride > 0) {
code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n");
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
code.format(" char * const attrib%d = (char *)malloc(%d);\n",
i, att.elemSize * (maxIndex + 1));
code.format(" assert(attrib%d);\n", i);
code.format(
" glVertexAttribPointer(%d, %d, %s, %b, %d, attrib%d);CHKERR;\n",
i, att.size, att.type, att.normalized, att.elemSize, i);
}
dataOut.write(attribData.array());
code.format(" for (%s i = 0; i < %d; i++) {\n", typeName, count);
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
code.format(
" fread(attrib%d + indexData[i] * %d, %d, 1, attribFile);\n",
i, att.elemSize, att.elemSize);
}
code.format(" }\n");
if (v.attribBuffer != null)
code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n",
v.attribBuffer.name);
}
code.format(" fclose(attribFile);\n");
}
if (v.indexBuffer != null)
code.format(" glDrawElements(%s, %d, %s, (const void *)%d);CHKERR;\n",
mode, count, type, msgData.msg.getArg3());
else {
code.format(" glDrawElements(%s, %d, %s, indexData);CHKERR;\n",
mode, count, type);
code.format(" free(indexData);\n");
}
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
if (!att.enabled)
continue;
if (att.buffer != null)
continue;
code.format(" free(attrib%d);\n", i);
}
code.write("};\n");
}
private void codeGenDraw(final GLServerVertex v, final MessageData msgData)
throws IOException {
final int maxAttrib = msgData.msg.getArg7();
if (maxAttrib < 1) {
code.write("// no vertex data\n");
return;
}
final int count = msgData.attribs[0].length / 4;
final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0());
final ByteBuffer attribData = ByteBuffer.allocate(maxAttrib * count * 16);
attribData.order(SampleView.targetByteOrder);
for (int i = 0; i < count; i++)
for (int j = 0; j < maxAttrib; j++)
for (int k = 0; k < 4; k++)
attribData.putFloat(msgData.attribs[j][i * 4 + k]);
assert attribData.remaining() == 0;
code.write("{\n");
code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n");
code.format(" assert(attribFile);CHKERR;\n");
code.format(" fseek(attribFile, 0x%X, SEEK_SET);CHKERR;\n",
dataOut.getChannel().position());
dataOut.write(attribData.array());
code.format(" char * const attribData = (char *)malloc(%d);\n", attribData.capacity());
code.format(" assert(attribData);\n");
code.format(" fread(attribData, %d, 1, attribFile);\n", attribData.capacity());
code.format(" fclose(attribFile);\n");
code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n");
for (int i = 0; i < maxAttrib; i++) {
final GLAttribPointer att = v.attribPointers[i];
assert msgData.attribs[i].length == count * 4;
code.format(
" glVertexAttribPointer(%d, %d, GL_FLOAT, GL_FALSE, %d, attribData + %d);CHKERR;\n",
i, att.size, maxAttrib * 16, i * 16);
}
code.format(" glDrawArrays(%s, 0, %d);CHKERR;\n", mode, count);
code.format(" free(attribData);\n");
if (v.attribBuffer != null)
code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n",
v.attribBuffer.name);
code.write("};\n");
}
private void codeGenFunction(final Context ctx, final MessageData msgData)
throws IOException {
final Message msg = msgData.msg;
String call = MessageFormatter.format(msg, true);
switch (msg.getFunction()) {
case glActiveTexture:
case glAttachShader:
case glBindAttribLocation:
break;
case glBindBuffer:
case glBindFramebuffer:
case glBindRenderbuffer:
case glBindTexture:
codeGenBindNames(msg);
return;
case glBlendColor:
case glBlendEquation:
case glBlendEquationSeparate:
case glBlendFunc:
case glBlendFuncSeparate:
break;
case glBufferData:
call = MessageFormatter.format(msg, true).replace("arg2", "bufferData");
codeGenBufferData(msg.getData().asReadOnlyByteBuffer(), call);
return;
case glBufferSubData:
call = MessageFormatter.format(msg, true).replace("arg3", "bufferData");
codeGenBufferData(msg.getData().asReadOnlyByteBuffer(), call);
return;
case glCheckFramebufferStatus:
case glClear:
case glClearColor:
case glClearDepthf:
case glClearStencil:
case glColorMask:
case glCompileShader:
break;
case glCompressedTexImage2D:
case glCompressedTexSubImage2D:
case glCopyTexImage2D:
case glCopyTexSubImage2D:
codeGenTextureUpload(msg, false);
return;
case glCreateProgram:
namesHeader.format("extern GLuint program_%d;\n", msg.getRet());
namesSource.format("GLuint program_%d = 0;\n", msg.getRet());
code.format("program_%d = glCreateProgram();CHKERR;\n", msg.getRet());
return;
case glCreateShader:
namesHeader.format("extern GLuint shader_%d;\n", msg.getRet());
namesSource.format("GLuint shader_%d = 0;\n", msg.getRet());
code.format("shader_%d = %s;\n", msg.getRet(), call);
return;
case glCullFace:
break;
case glDeleteBuffers:
case glDeleteFramebuffers:
case glDeleteProgram:
programNames.put(msg.getArg0(), 0);
break;
case glDeleteRenderbuffers:
codeGenDeleteNames(msg);
return;
case glDeleteShader:
shaderNames.put(msg.getArg0(), 0);
return;
case glDeleteTextures:
codeGenDeleteNames(msg);
return;
case glDepthFunc:
case glDepthMask:
case glDepthRangef:
case glDetachShader:
case glDisable:
case glDisableVertexAttribArray:
break;
case glDrawArrays:
// CodeGenDraw(ctx.serverVertex, msgData);
codeGenDrawArrays(ctx.serverVertex, msgData);
return;
case glDrawElements:
// CodeGenDraw(ctx.serverVertex, msgData);
codeGenDrawElements(ctx.serverVertex, msgData);
return;
case glEnable:
case glEnableVertexAttribArray:
case glFinish:
case glFlush:
case glFramebufferRenderbuffer:
case glFramebufferTexture2D:
case glFrontFace:
break;
case glGenBuffers:
codeGenGenNames(msg);
return;
case glGenerateMipmap:
break;
case glGenFramebuffers:
case glGenRenderbuffers:
case glGenTextures:
codeGenGenNames(msg);
return;
case glGetActiveAttrib:
case glGetActiveUniform:
case glGetAttachedShaders:
break;
case glGetAttribLocation:
call = String.format("assert(%d == %s)", msg.getRet(), call);
break;
case glGetBooleanv:
case glGetBufferParameteriv:
return; // TODO
case glGetError:
code.write("CHKERR;\n");
return;
case glGetFloatv:
case glGetFramebufferAttachmentParameteriv:
case glGetIntegerv:
case glGetProgramiv:
case glGetProgramInfoLog:
case glGetRenderbufferParameteriv:
case glGetShaderiv:
case glGetShaderInfoLog:
case glGetShaderPrecisionFormat:
case glGetShaderSource:
case glGetString:
case glGetTexParameterfv:
case glGetTexParameteriv:
case glGetUniformfv:
case glGetUniformiv:
return;
case glGetUniformLocation:
call = String.format("assert(%d == %s)", msg.getRet(), call);
break;
case glGetVertexAttribfv:
case glGetVertexAttribiv:
case glGetVertexAttribPointerv:
return; // TODO
case glHint:
case glIsBuffer:
case glIsEnabled:
case glIsFramebuffer:
case glIsProgram:
case glIsRenderbuffer:
case glIsShader:
case glIsTexture:
case glLineWidth:
case glLinkProgram:
case glPixelStorei:
case glPolygonOffset:
break;
case glReadPixels:
return; // TODO
case glReleaseShaderCompiler:
case glRenderbufferStorage:
case glSampleCoverage:
case glScissor:
break;
case glShaderBinary:
return; // TODO
case glShaderSource:
call = String.format(
"glShaderSource(shader_%d, 1, (const char * []){\"%s\"}, NULL)",
msg.getArg0(),
msg.getData().toStringUtf8().replace("\r", "").replace("\n", "\\n\\\n")
.replace("\"", "\\\"")
);
break;
case glStencilFunc:
case glStencilFuncSeparate:
case glStencilMask:
case glStencilMaskSeparate:
case glStencilOp:
case glStencilOpSeparate:
break;
case glTexImage2D:
codeGenTextureUpload(msg, false);
return;
case glTexParameterf:
break;
case glTexParameterfv:
return; // TODO
case glTexParameteri:
break;
case glTexParameteriv:
return; // TODO
case glTexSubImage2D:
codeGenTextureUpload(msg, false);
return;
case glUniform1f:
case glUniform1fv:
case glUniform1i:
case glUniform1iv:
case glUniform2f:
case glUniform2fv:
case glUniform2i:
case glUniform2iv:
case glUniform3f:
case glUniform3fv:
case glUniform3i:
case glUniform3iv:
case glUniform4f:
case glUniform4fv:
case glUniform4i:
case glUniform4iv:
case glUniformMatrix2fv:
case glUniformMatrix3fv:
case glUniformMatrix4fv:
case glUseProgram:
case glValidateProgram:
case glVertexAttrib1f:
case glVertexAttrib1fv:
case glVertexAttrib2f:
case glVertexAttrib2fv:
case glVertexAttrib3f:
case glVertexAttrib3fv:
case glVertexAttrib4f:
case glVertexAttrib4fv:
break;
case glVertexAttribPointer:
// if it's user pointer, then CodeGenDrawArrays/Elements will
// replace it with loaded data just before the draw
call = call.replace("arg5", "(const void *)0x" +
Integer.toHexString(msg.getArg5()));
break;
case glViewport:
break;
case eglSwapBuffers:
return;
default:
assert false;
return;
}
if (call.indexOf("glEnable(/*cap*/ GL_TEXTURE_2D)") >= 0)
return;
else if (call.indexOf("glDisable(/*cap*/ GL_TEXTURE_2D)") >= 0)
return;
else if (call.indexOf("glActiveTexture(/*texture*/ GL_TEXTURE_2D)") >= 0)
return;
code.write(call + ";CHKERR;\n");
}
private void codeGenSetup(final Context ctx) {
try {
codeFile = new FileWriter("frame_setup.cpp", false);
code = new PrintWriter(codeFile);
dataOut = new FileOutputStream("frame_data.bin", false);
namesHeaderFile = new FileWriter("frame_names.h", false);
namesHeader = new PrintWriter(namesHeaderFile);
namesSourceFile = new FileWriter("frame_names.cpp", false);
namesSource = new PrintWriter(namesSourceFile);
} catch (IOException e) {
e.printStackTrace();
assert false;
}
bufferNames = new SparseIntArray();
framebufferNames = new SparseIntArray();
programNames = new SparseIntArray();
textureNames = new SparseIntArray();
shaderNames = new SparseIntArray();
renderbufferNames = new SparseIntArray();
namesHeader.write("#include <stdlib.h>\n");
namesHeader.write("#include <stdio.h>\n");
namesHeader.write("#include <assert.h>\n");
namesHeader.write("#include <GLES2/gl2.h>\n");
namesHeader.write("#include <GLES2/gl2ext.h>\n");
namesHeader.write("#define CHKERR assert(GL_NO_ERROR == glGetError());/**/\n");
namesHeader.write("void FrameSetup();\n");
namesHeader.write("extern const unsigned int FrameCount;\n");
namesHeader.write("extern const GLuint program_0;\n");
namesSource.write("/*\n" +
" * Copyright (C) 2011 The Android Open Source Project\n" +
" *\n" +
" * Licensed under the Apache License, Version 2.0 (the \"License\");\n" +
" * you may not use this file except in compliance with the License.\n" +
" * You may obtain a copy of the License at\n" +
" *\n" +
" * http://www.apache.org/licenses/LICENSE-2.0\n" +
" *\n" +
" * Unless required by applicable law or agreed to in writing, software\n" +
" * distributed under the License is distributed on an \"AS IS\" BASIS,\n" +
" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" +
" * See the License for the specific language governing permissions and\n" +
" * limitations under the License.\n" +
" */\n" +
"\n" +
"#include <stdlib.h>\n" +
"#include <stdio.h>\n" +
"\n" +
"#include <EGL/egl.h>\n" +
"#include <GLES2/gl2.h>\n" +
"#include <GLES2/gl2ext.h>\n" +
"\n" +
"#include <ui/FramebufferNativeWindow.h>\n" +
"#include <ui/EGLUtils.h>\n" +
"\n" +
"#include <private/ui/android_natives_priv.h>\n" +
"\n" +
"#include <surfaceflinger/Surface.h>\n" +
"#include <surfaceflinger/ISurface.h>\n" +
"#include <surfaceflinger/SurfaceComposerClient.h>\n" +
"\n" +
"using namespace android;\n" +
"\n" +
"static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE)\n" +
"{\n" +
" if (returnVal != EGL_TRUE) {\n" +
" fprintf(stderr, \"%s() returned %d\\n\", op, returnVal);\n" +
" }\n" +
"\n" +
" for (EGLint error = eglGetError(); error != EGL_SUCCESS; error\n" +
" = eglGetError()) {\n" +
" fprintf(stderr, \"after %s() eglError %s (0x%x)\\n\", op, EGLUtils::strerror(error),\n" +
" error);\n" +
" }\n" +
"}\n" +
"\n" +
"static EGLDisplay dpy;\n" +
"static EGLSurface surface;\n" +
"\n" +
"#include \"frame_names.h\"\n" +
"const GLuint program_0 = 0;\n" +
"int main(int argc, char** argv)\n" +
"{\n" +
" EGLBoolean returnValue;\n" +
" EGLConfig myConfig = {0};\n" +
"\n" +
" EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };\n" +
" EGLint majorVersion;\n" +
" EGLint minorVersion;\n" +
" EGLContext context;\n" +
" EGLint w, h;\n" +
"\n" +
"\n" +
" checkEglError(\"<init>\");\n" +
" dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);\n" +
" checkEglError(\"eglGetDisplay\");\n" +
" if (dpy == EGL_NO_DISPLAY) {\n" +
" printf(\"eglGetDisplay returned EGL_NO_DISPLAY.\\n\");\n" +
" return 0;\n" +
" }\n" +
"\n" +
" returnValue = eglInitialize(dpy, &majorVersion, &minorVersion);\n" +
" checkEglError(\"eglInitialize\", returnValue);\n" +
" if (returnValue != EGL_TRUE) {\n" +
" printf(\"eglInitialize failed\\n\");\n" +
" return 0;\n" +
" }\n" +
"\n" +
" sp<SurfaceComposerClient> spClient;\n" +
" sp<SurfaceControl> spControl;\n" +
" sp<Surface> spSurface;\n" +
"\n" +
" // create a client to surfaceflinger\n" +
" spClient = new SurfaceComposerClient();\n" +
"\n" +
" spControl = spClient->createSurface(getpid(), 0, 1280, 752, PIXEL_FORMAT_RGBX_8888);\n" +
" spClient->openTransaction();\n" +
" spControl->setLayer(350000);\n" +
" spControl->show();\n" +
" spClient->closeTransaction();\n" +
"\n" +
" spSurface = spControl->getSurface();\n" +
" EGLNativeWindowType window = spSurface.get();\n" +
"\n" +
" printf(\"window=%p\\n\", window);\n" +
" EGLint attrib_list[] = {\n" +
" EGL_SURFACE_TYPE, EGL_WINDOW_BIT,\n" +
" EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,\n" +
" EGL_BUFFER_SIZE, 32,\n" +
" EGL_RED_SIZE, 8,\n" +
" EGL_GREEN_SIZE, 8,\n" +
" EGL_BLUE_SIZE, 8,\n" +
" EGL_NONE\n" +
" };\n" +
"\n" +
" EGLConfig configs[12] = {0};\n" +
" int num_config = -1;\n" +
" eglChooseConfig(dpy, attrib_list, configs, sizeof(configs) / sizeof(*configs), &num_config);\n" +
" printf(\"eglChooseConfig %d \\n\", num_config);\n" +
"\n" +
" surface = eglCreateWindowSurface(dpy, configs[0], window, NULL);\n" +
" checkEglError(\"eglCreateWindowSurface\");\n" +
" if (surface == EGL_NO_SURFACE) {\n" +
" printf(\"gelCreateWindowSurface failed.\\n\");\n" +
" return 0;\n" +
" }\n" +
"\n" +
" context = eglCreateContext(dpy, configs[0], EGL_NO_CONTEXT, context_attribs);\n" +
" checkEglError(\"eglCreateContext\");\n" +
" if (context == EGL_NO_CONTEXT) {\n" +
" printf(\"eglCreateContext failed\\n\");\n" +
" return 0;\n" +
" }\n" +
" printf(\"context=%p \\n\", context);\n" +
"\n" +
" returnValue = eglMakeCurrent(dpy, surface, surface, context);\n" +
" checkEglError(\"eglMakeCurrent\", returnValue);\n" +
" if (returnValue != EGL_TRUE) {\n" +
" return 0;\n" +
" }\n" +
"\n" +
" glClearColor(1,1,1,1);\n" +
" glClear(GL_COLOR_BUFFER_BIT);\n" +
"\n" +
" FrameSetup();\n" +
" while (true)\n" +
" for (unsigned int i = 0; i < FrameCount; i++) {\n" +
" Frames[i]();\n" +
" eglSwapBuffers(dpy, surface);\n" +
" printf(\"press ENTER after Frame%d \\n\", i);\n" +
" getchar();\n" +
" }\n" +
"\n" +
" return 0;\n" +
"}");
code.write("#include \"frame_names.h\"\n");
code.write("void FrameSetup(){\n");
codeGenServerState(ctx.serverState);
codeGenServerShader(ctx.serverShader);
codeGenServerTexture(ctx.serverTexture, true);
codeGenServerVertex(ctx.serverVertex);
code.write("}\n");
try {
codeFile.close();
makeFile = new FileWriter("Android.mk", false);
make = new PrintWriter(makeFile);
make.write("LOCAL_PATH:= $(call my-dir)\n" +
"include $(CLEAR_VARS)\n" +
"LOCAL_SRC_FILES := \\\n");
} catch (IOException e) {
e.printStackTrace();
assert false;
}
}
private void codeGenCleanup() {
make.write(" frame_setup.cpp \\\n");
make.write(" frame_names.cpp \\\n");
make.write("#\n");
make.write(
"LOCAL_SHARED_LIBRARIES := \\\n" +
" libcutils \\\n" +
" libutils \\\n" +
" libEGL \\\n" +
" libGLESv2 \\\n" +
" libui \\\n" +
" libhardware \\\n" +
" libgui\n" +
"\n" +
"LOCAL_MODULE:= gles2dbg\n" +
"\n" +
"LOCAL_MODULE_TAGS := optional\n" +
"\n" +
"LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -O0 -g -DDEBUG -UNDEBUG\n" +
"\n" +
"include $(BUILD_EXECUTABLE)");
try {
dataOut.flush();
dataOut.close();
codeFile.close();
makeFile.close();
namesHeaderFile.close();
namesSourceFile.close();
} catch (IOException e) {
e.printStackTrace();
assert false;
}
dataOut = null;
code = null;
codeFile = null;
make = null;
makeFile = null;
bufferNames = null;
framebufferNames = null;
programNames = null;
textureNames = null;
shaderNames = null;
renderbufferNames = null;
}
private DebugContext dbgCtx;
private int count;
private IProgressMonitor progress;
@Override
public void run(IProgressMonitor monitor) {
progress.beginTask("CodeGenFrames", count + 2);
Context ctx = dbgCtx.getFrame(0).startContext.clone();
codeGenSetup(ctx);
progress.worked(1);
for (int i = 0; i < count; i++) {
try {
codeFile = new FileWriter("frame" + i + ".cpp", false);
code = new PrintWriter(codeFile);
} catch (IOException e1) {
e1.printStackTrace();
assert false;
}
make.format(" frame%d.cpp \\\n", i);
code.write("#include \"frame_names.h\"\n");
code.format("void Frame%d(){\n", i);
final Frame frame = dbgCtx.getFrame(i);
for (int j = 0; j < frame.size(); j++) {
final MessageData msgData = frame.get(j);
code.format("/* frame function %d: %s %s*/\n", j, msgData.msg.getFunction(),
MessageFormatter.format(msgData.msg, false));
ctx.processMessage(msgData.msg);
try {
codeGenFunction(ctx, msgData);
} catch (IOException e) {
e.printStackTrace();
assert false;
}
}
code.write("}\n");
try {
codeFile.close();
} catch (IOException e) {
e.printStackTrace();
assert false;
}
progress.worked(1);
}
for (int i = 0; i < count; i++)
namesHeader.format("void Frame%d();\n", i);
namesHeader.format("extern void (* Frames[%d])();\n", count);
namesSource.format("void (* Frames[%d])() = {\n", count);
for (int i = 0; i < count; i++) {
namesSource.format(" Frame%d,\n", i);
}
namesSource.write("};\n");
namesSource.format("const unsigned int FrameCount = %d;\n", count);
codeGenCleanup();
progress.worked(1);
}
void codeGenFrames(final DebugContext dbgCtx, int count, final Shell shell) {
this.dbgCtx = dbgCtx;
this.count = count;
ProgressMonitorDialog dialog = new ProgressMonitorDialog(shell);
this.progress = dialog.getProgressMonitor();
try {
dialog.run(false, true, this);
} catch (InvocationTargetException e) {
e.printStackTrace();
assert false;
} catch (InterruptedException e) {
e.printStackTrace();
}
this.dbgCtx = null;
this.count = 0;
progress = null;
}
void codeGenFrame(final Frame frame) {
Context ctx = frame.startContext.clone();
codeGenSetup(ctx);
try {
codeFile = new FileWriter("frame0.cpp", false);
code = new PrintWriter(codeFile);
} catch (IOException e1) {
e1.printStackTrace();
assert false;
}
make.format(" frame0.cpp \\\n");
code.write("#include \"frame_names.h\"\n");
code.format("void Frame0(){\n");
for (int i = 0; i < frame.size(); i++) {
final MessageData msgData = frame.get(i);
code.format("/* frame function %d: %s %s*/\n", i, msgData.msg.getFunction(),
MessageFormatter.format(msgData.msg, false));
ctx.processMessage(msgData.msg);
try {
codeGenFunction(ctx, msgData);
} catch (IOException e) {
e.printStackTrace();
assert false;
}
}
code.write("}\n");
namesHeader.write("void Frame0();\n");
namesHeader.write("extern void (* Frames[1])();\n");
namesSource.write("void (* Frames[1])() = {Frame0};\n");
namesSource.write("const unsigned int FrameCount = 1;\n");
codeGenCleanup();
}
}