| /* |
| ** 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.sdklib.util.SparseArray; |
| |
| import java.nio.ByteBuffer; |
| |
| class GLBuffer implements Cloneable { |
| public final int name; |
| public GLEnum usage; |
| public GLEnum target; |
| /** in SampleView.targetByteOrder */ |
| public ByteBuffer data; |
| |
| public GLBuffer(final int name) { |
| this.name = name; |
| } |
| |
| /** deep copy */ |
| @Override |
| public GLBuffer clone() { |
| try { |
| GLBuffer copy = (GLBuffer) super.clone(); |
| if (data != null) { |
| copy.data = ByteBuffer.allocate(data.capacity()); |
| copy.data.order(SampleView.targetByteOrder); |
| data.position(0); |
| copy.data.put(data); |
| } |
| return copy; |
| } catch (CloneNotSupportedException e) { |
| e.printStackTrace(); |
| assert false; |
| return null; |
| } |
| } |
| } |
| |
| class GLAttribPointer implements Cloneable { |
| public int size; // number of values per vertex |
| public GLEnum type; // data type |
| public int stride; // bytes |
| /** |
| * element stride in bytes, used when fetching from buffer; not for fetching |
| * from user pointer since server already packed elements |
| */ |
| int elemStride; // in bytes |
| /** element size in bytes */ |
| int elemSize; |
| public int ptr; // pointer in debugger server or byte offset into buffer |
| public GLBuffer buffer; |
| public boolean normalized; |
| public boolean enabled; |
| |
| /** deep copy, re-maps buffer into copyBuffers */ |
| public GLAttribPointer clone(SparseArray<GLBuffer> copyBuffers) { |
| try { |
| GLAttribPointer copy = (GLAttribPointer) super.clone(); |
| if (buffer != null) |
| copy.buffer = copyBuffers.get(buffer.name); |
| return copy; |
| } catch (CloneNotSupportedException e) { |
| e.printStackTrace(); |
| assert false; |
| return null; |
| } |
| } |
| } |
| |
| public class GLServerVertex implements Cloneable { |
| public SparseArray<GLBuffer> buffers = new SparseArray<GLBuffer>(); |
| public GLBuffer attribBuffer, indexBuffer; // current binding |
| public GLAttribPointer attribPointers[]; |
| public float defaultAttribs[][]; |
| |
| public GLServerVertex(final int MAX_VERTEX_ATTRIBS) { |
| buffers.append(0, null); |
| attribPointers = new GLAttribPointer[MAX_VERTEX_ATTRIBS]; |
| for (int i = 0; i < attribPointers.length; i++) |
| attribPointers[i] = new GLAttribPointer(); |
| defaultAttribs = new float[MAX_VERTEX_ATTRIBS][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; |
| } |
| } |
| |
| /** deep copy */ |
| @Override |
| public GLServerVertex clone() { |
| try { |
| GLServerVertex copy = (GLServerVertex) super.clone(); |
| |
| copy.buffers = new SparseArray<GLBuffer>(buffers.size()); |
| for (int i = 0; i < buffers.size(); i++) |
| if (buffers.valueAt(i) != null) |
| copy.buffers.append(buffers.keyAt(i), buffers.valueAt(i).clone()); |
| else |
| copy.buffers.append(buffers.keyAt(i), null); |
| |
| if (attribBuffer != null) |
| copy.attribBuffer = copy.buffers.get(attribBuffer.name); |
| if (indexBuffer != null) |
| copy.indexBuffer = copy.buffers.get(indexBuffer.name); |
| |
| copy.attribPointers = new GLAttribPointer[attribPointers.length]; |
| for (int i = 0; i < attribPointers.length; i++) |
| copy.attribPointers[i] = attribPointers[i].clone(copy.buffers); |
| |
| copy.defaultAttribs = defaultAttribs.clone(); |
| |
| return copy; |
| } catch (CloneNotSupportedException e) { |
| e.printStackTrace(); |
| assert false; |
| return null; |
| } |
| } |
| |
| /** returns true if processed */ |
| public boolean process(final Message msg) { |
| switch (msg.getFunction()) { |
| case glBindBuffer: |
| glBindBuffer(msg); |
| return true; |
| case glBufferData: |
| glBufferData(msg); |
| return true; |
| case glBufferSubData: |
| glBufferSubData(msg); |
| return true; |
| case glDeleteBuffers: |
| glDeleteBuffers(msg); |
| return true; |
| case glDrawArrays: |
| case glDrawElements: |
| return true; |
| case glDisableVertexAttribArray: |
| glDisableVertexAttribArray(msg); |
| return true; |
| case glEnableVertexAttribArray: |
| glEnableVertexAttribArray(msg); |
| return true; |
| case glGenBuffers: |
| glGenBuffers(msg); |
| return true; |
| case glVertexAttribPointer: |
| glVertexAttribPointer(msg); |
| return true; |
| case glVertexAttrib1f: |
| glVertexAttrib1f(msg); |
| return true; |
| case glVertexAttrib1fv: |
| glVertexAttrib1fv(msg); |
| return true; |
| case glVertexAttrib2f: |
| glVertexAttrib2f(msg); |
| return true; |
| case glVertexAttrib2fv: |
| glVertexAttrib2fv(msg); |
| return true; |
| case glVertexAttrib3f: |
| glVertexAttrib3f(msg); |
| return true; |
| case glVertexAttrib3fv: |
| glVertexAttrib3fv(msg); |
| return true; |
| case glVertexAttrib4f: |
| glVertexAttrib4f(msg); |
| return true; |
| case glVertexAttrib4fv: |
| glVertexAttrib4fv(msg); |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // 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(); |
| attribBuffer.data.order(SampleView.targetByteOrder); |
| } else if (GLEnum.valueOf(msg.getArg0()) == GLEnum.GL_ELEMENT_ARRAY_BUFFER) { |
| indexBuffer.usage = GLEnum.valueOf(msg.getArg3()); |
| indexBuffer.data = msg.getData().asReadOnlyByteBuffer(); |
| indexBuffer.data.order(SampleView.targetByteOrder); |
| } 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.order(SampleView.targetByteOrder); |
| 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.order(SampleView.targetByteOrder); |
| 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(); |
| names.order(SampleView.targetByteOrder); |
| for (int i = 0; i < n; i++) { |
| final int name = names.getInt(); |
| final 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) { |
| if (msg.getArg0() >= 0 && msg.getArg0() < attribPointers.length) |
| attribPointers[msg.getArg0()].enabled = false; |
| } |
| |
| float fetchConvert(final ByteBuffer src, final GLEnum type, final boolean normalized) { |
| if (GLEnum.GL_FLOAT == type) |
| return Float.intBitsToFloat(src.getInt()); |
| else if (GLEnum.GL_UNSIGNED_INT == type) |
| if (normalized) |
| return (src.getInt() & 0xffffffffL) / (2e32f - 1); |
| else |
| return src.getInt() & 0xffffffffL; |
| else if (GLEnum.GL_INT == type) |
| if (normalized) |
| return (src.getInt() * 2 + 1) / (2e32f - 1); |
| else |
| return src.getInt(); |
| else if (GLEnum.GL_UNSIGNED_SHORT == type) |
| if (normalized) |
| return (src.getShort() & 0xffff) / (2e16f - 1); |
| else |
| return src.getShort() & 0xffff; |
| else if (GLEnum.GL_SHORT == type) |
| if (normalized) |
| return (src.getShort() * 2 + 1) / (2e16f - 1); |
| else |
| return 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 (src.getInt() * 2 + 1) / (2e32f - 1); |
| else |
| return src.getInt() / (2e16f); |
| else |
| assert false; |
| return 0; |
| } |
| |
| static int typeSize(final GLEnum type) { |
| switch (type) { |
| case GL_FLOAT: |
| case GL_UNSIGNED_INT: |
| case GL_INT: |
| case GL_FIXED: |
| return 4; |
| case GL_UNSIGNED_SHORT: |
| case GL_SHORT: |
| return 2; |
| case GL_UNSIGNED_BYTE: |
| case GL_BYTE: |
| return 1; |
| default: |
| assert false; |
| return 0; |
| } |
| } |
| |
| void fetch(final int maxAttrib, final int index, final int dstIdx, final ByteBuffer nonVBO, |
| final float[][] fetchedAttribs) { |
| 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 + index * attrib.elemStride); |
| for (int j = 0; j < size; j++) |
| fetchedAttribs[i][dstIdx * 4 + j] = fetchConvert(src, attrib.type, |
| attrib.normalized); |
| } else |
| for (int j = 0; j < size; j++) |
| fetchedAttribs[i][dstIdx * 4 + j] = fetchConvert(nonVBO, attrib.type, |
| attrib.normalized); |
| } |
| if (size < 1) |
| fetchedAttribs[i][dstIdx * 4 + 0] = defaultAttribs[i][0]; |
| if (size < 2) |
| fetchedAttribs[i][dstIdx * 4 + 1] = defaultAttribs[i][1]; |
| if (size < 3) |
| fetchedAttribs[i][dstIdx * 4 + 2] = defaultAttribs[i][2]; |
| if (size < 4) |
| fetchedAttribs[i][dstIdx * 4 + 3] = defaultAttribs[i][3]; |
| } |
| } |
| |
| /** |
| * fetches and converts vertex data from buffers, defaults and user pointers |
| * into MessageData; mainly for display use |
| */ |
| public void glDrawArrays(MessageData msgData) { |
| final Message msg = msgData.msg; |
| if (!msg.hasArg7()) |
| return; |
| final int maxAttrib = msg.getArg7(); |
| final int first = msg.getArg1(), count = msg.getArg2(); |
| msgData.attribs = new float[maxAttrib][count * 4]; |
| ByteBuffer arrays = null; |
| if (msg.hasData()) // server sends user pointer attribs |
| { |
| arrays = msg.getData().asReadOnlyByteBuffer(); |
| arrays.order(SampleView.targetByteOrder); |
| } |
| for (int i = 0; i < count; i++) |
| fetch(maxAttrib, first + i, i, arrays, msgData.attribs); |
| assert null == arrays || arrays.remaining() == 0; |
| } |
| |
| // void glDrawElements(GLenum mode, GLsizei count, GLenum type, const |
| // GLvoid* indices) |
| /** |
| * fetches and converts vertex data from buffers, defaults and user pointers |
| * and indices from buffer/pointer into MessageData; mainly for display use |
| */ |
| public void glDrawElements(MessageData msgData) { |
| final Message msg = msgData.msg; |
| if (!msg.hasArg7()) |
| return; |
| final int maxAttrib = msg.getArg7(); |
| final int count = msg.getArg1(); |
| final GLEnum type = GLEnum.valueOf(msg.getArg2()); |
| msgData.attribs = new float[maxAttrib][count * 4]; |
| msgData.indices = new short[count]; |
| ByteBuffer arrays = null, index = null; |
| if (msg.hasData()) // server sends user pointer attribs |
| { |
| arrays = msg.getData().asReadOnlyByteBuffer(); |
| arrays.order(SampleView.targetByteOrder); |
| } |
| 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++) { |
| msgData.indices[i] = index.getShort(); |
| fetch(maxAttrib, msgData.indices[i] & 0xffff, i, arrays, msgData.attribs); |
| } |
| } else if (GLEnum.GL_UNSIGNED_BYTE == type) { |
| for (int i = 0; i < count; i++) { |
| msgData.indices[i] = (short) (index.get() & 0xff); |
| fetch(maxAttrib, msgData.indices[i], i, arrays, msgData.attribs); |
| } |
| } else |
| assert false; |
| assert null == arrays || arrays.remaining() == 0; |
| } |
| |
| // void glEnableVertexAttribArray(GLuint index) |
| public void glEnableVertexAttribArray(Message msg) { |
| if (msg.getArg0() >= 0 && msg.getArg0() < attribPointers.length) |
| 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(); |
| buffer.order(SampleView.targetByteOrder); |
| for (int i = 0; i < n; i++) { |
| final int name = buffer.getInt(); |
| final int index = buffers.indexOfKey(name); |
| if (index < 0) |
| buffers.append(name, new GLBuffer(name)); |
| } |
| } |
| |
| // 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(); |
| attrib.elemSize = attrib.size * typeSize(attrib.type); |
| if (attrib.stride == 0) |
| attrib.elemStride = attrib.elemSize; |
| else |
| attrib.elemStride = attrib.stride; |
| attrib.ptr = msg.getArg5(); |
| attrib.buffer = attribBuffer; |
| } |
| |
| // void glVertexAttrib1f(GLuint indx, GLfloat x) |
| public void glVertexAttrib1f(Message msg) { |
| glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), |
| 0, 0, 1); |
| } |
| |
| // void glVertexAttrib1fv(GLuint indx, const GLfloat* values) |
| public void glVertexAttrib1fv(Message msg) { |
| final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); |
| values.order(SampleView.targetByteOrder); |
| glVertexAttrib4f(msg.getArg0(), |
| Float.intBitsToFloat(values.getInt()), |
| 0, 0, 1); |
| } |
| |
| // void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) |
| public void glVertexAttrib2f(Message msg) { |
| glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), |
| Float.intBitsToFloat(msg.getArg2()), 0, 1); |
| } |
| |
| // void glVertexAttrib2fv(GLuint indx, const GLfloat* values) |
| public void glVertexAttrib2fv(Message msg) { |
| final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); |
| values.order(SampleView.targetByteOrder); |
| glVertexAttrib4f(msg.getArg0(), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt()), 0, 1); |
| } |
| |
| // void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) |
| public void glVertexAttrib3f(Message msg) { |
| glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), |
| Float.intBitsToFloat(msg.getArg2()), |
| Float.intBitsToFloat(msg.getArg3()), 1); |
| } |
| |
| // void glVertexAttrib3fv(GLuint indx, const GLfloat* values) |
| public void glVertexAttrib3fv(Message msg) { |
| final ByteBuffer values = msg.getData().asReadOnlyByteBuffer(); |
| values.order(SampleView.targetByteOrder); |
| glVertexAttrib4f(msg.getArg0(), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt()), 1); |
| } |
| |
| public void glVertexAttrib4f(Message msg) { |
| glVertexAttrib4f(msg.getArg0(), Float.intBitsToFloat(msg.getArg1()), |
| Float.intBitsToFloat(msg.getArg2()), |
| Float.intBitsToFloat(msg.getArg3()), |
| Float.intBitsToFloat(msg.getArg4())); |
| } |
| |
| void glVertexAttrib4f(int indx, float x, float y, float z, float w) { |
| if (indx < 0 || indx >= defaultAttribs.length) |
| return; |
| 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(); |
| values.order(SampleView.targetByteOrder); |
| glVertexAttrib4f(msg.getArg0(), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt()), |
| Float.intBitsToFloat(values.getInt())); |
| } |
| } |
