9 files changed, 1135 insertions, 605 deletions

diff --git a/opengl/java/android/opengl/GLES11.java b/opengl/java/android/opengl/GLES11.java
index 3399af7..1ca179b 100644
--- a/opengl/java/android/opengl/GLES11.java
+++ b/opengl/java/android/opengl/GLES11.java
@@ -150,6 +150,7 @@ public class GLES11 extends GLES10 {
 	    _nativeClassInit();
     }
 
+    private static Buffer _pointSizePointerOES;
     // C function void glBindBuffer ( GLenum target, GLuint buffer )
 
     public static native void glBindBuffer(
@@ -596,12 +597,31 @@ public class GLES11 extends GLES10 {
 
     // C function void glPointSizePointerOES ( GLenum type, GLsizei stride, const GLvoid *pointer )
 
-    public static native void glPointSizePointerOES(
+    private static native void glPointSizePointerOESBounds(
         int type,
         int stride,
-        java.nio.Buffer pointer
+        java.nio.Buffer pointer,
+        int remaining
     );
 
+    public static void glPointSizePointerOES(
+        int type,
+        int stride,
+        java.nio.Buffer pointer
+    ) {
+        glPointSizePointerOESBounds(
+            type,
+            stride,
+            pointer,
+            pointer.remaining()
+        );
+        if (((type == GL_FLOAT) ||
+             (type == GL_FIXED)) &&
+            (stride >= 0)) {
+            _pointSizePointerOES = pointer;
+        }
+    }
+
     // C function void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, GLint offset )
 
     public static native void glTexCoordPointer(
diff --git a/opengl/java/android/opengl/GLES11Ext.java b/opengl/java/android/opengl/GLES11Ext.java
index 4384e9e..25d5467 100644
--- a/opengl/java/android/opengl/GLES11Ext.java
+++ b/opengl/java/android/opengl/GLES11Ext.java
@@ -19,6 +19,8 @@
 
 package android.opengl;
 
+import java.nio.Buffer;
+
 public class GLES11Ext {
     public static final int GL_BLEND_EQUATION_RGB_OES                               = 0x8009;
     public static final int GL_BLEND_EQUATION_ALPHA_OES                             = 0x883D;
@@ -129,6 +131,12 @@ public class GLES11Ext {
 	    _nativeClassInit();
     }
     
+    private static final int GL_BYTE = GLES10.GL_BYTE;
+    private static final int GL_FIXED = GLES10.GL_FIXED;
+    private static final int GL_FLOAT = GLES10.GL_FLOAT;
+    private static final int GL_SHORT = GLES10.GL_SHORT;
+    
+    private static Buffer _matrixIndexPointerOES;
     // C function void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha )
 
     public static native void glBlendEquationSeparateOES(
@@ -866,22 +874,64 @@ public class GLES11Ext {
 
     // C function void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
 
-    public static native void glMatrixIndexPointerOES(
+    private static native void glMatrixIndexPointerOESBounds(
         int size,
         int type,
         int stride,
-        java.nio.Buffer pointer
+        java.nio.Buffer pointer,
+        int remaining
     );
 
+    public static void glMatrixIndexPointerOES(
+        int size,
+        int type,
+        int stride,
+        java.nio.Buffer pointer
+    ) {
+        glMatrixIndexPointerOESBounds(
+            size,
+            type,
+            stride,
+            pointer,
+            pointer.remaining()
+        );
+        if (((size == 2) ||
+             (size == 3) ||
+             (size == 4)) &&
+            ((type == GL_FLOAT) ||
+             (type == GL_BYTE) ||
+             (type == GL_SHORT) ||
+             (type == GL_FIXED)) &&
+            (stride >= 0)) {
+            _matrixIndexPointerOES = pointer;
+        }
+    }
+
     // C function void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
 
-    public static native void glWeightPointerOES(
+    private static native void glWeightPointerOESBounds(
         int size,
         int type,
         int stride,
-        java.nio.Buffer pointer
+        java.nio.Buffer pointer,
+        int remaining
     );
 
+    public static void glWeightPointerOES(
+        int size,
+        int type,
+        int stride,
+        java.nio.Buffer pointer
+    ) {
+        glWeightPointerOESBounds(
+            size,
+            type,
+            stride,
+            pointer,
+            pointer.remaining()
+        );
+    }
+
     // C function void glDepthRangefOES ( GLclampf zNear, GLclampf zFar )
 
     public static native void glDepthRangefOES(
diff --git a/opengl/java/android/opengl/GLES20.java b/opengl/java/android/opengl/GLES20.java
index 7ce318f..b8aac0e 100644
--- a/opengl/java/android/opengl/GLES20.java
+++ b/opengl/java/android/opengl/GLES20.java
@@ -20,7 +20,6 @@
 package android.opengl;
 
 /** OpenGL ES 2.0
- * @hide
  */
 public class GLES20 {
     public static final int GL_ACTIVE_TEXTURE                          = 0x84E0;
diff --git a/opengl/java/android/opengl/GLErrorWrapper.java b/opengl/java/android/opengl/GLErrorWrapper.java
index 884a1a0..9b66e49 100644
--- a/opengl/java/android/opengl/GLErrorWrapper.java
+++ b/opengl/java/android/opengl/GLErrorWrapper.java
@@ -958,4 +958,424 @@ class GLErrorWrapper extends GLWrapperBase {
         checkError();
         return valid;
     }
+
+    public void glBindBuffer(int target, int buffer) {
+        checkThread();
+        mgl11.glBindBuffer(target, buffer);
+        checkError();
+    }
+
+    public void glBufferData(int target, int size, Buffer data, int usage) {
+        checkThread();
+        mgl11.glBufferData(target, size, data, usage);
+        checkError();
+    }
+
+    public void glBufferSubData(int target, int offset, int size, Buffer data) {
+        checkThread();
+        mgl11.glBufferSubData(target, offset, size, data);
+        checkError();
+    }
+
+    public void glColor4ub(byte red, byte green, byte blue, byte alpha) {
+        checkThread();
+        mgl11.glColor4ub(red, green, blue, alpha);
+        checkError();    }
+
+    public void glColorPointer(int size, int type, int stride, int offset) {
+        checkThread();
+        mgl11.glColorPointer(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glDeleteBuffers(int n, int[] buffers, int offset) {
+        checkThread();
+        mgl11.glDeleteBuffers(n, buffers, offset);
+        checkError();
+    }
+
+    public void glDeleteBuffers(int n, IntBuffer buffers) {
+        checkThread();
+        mgl11.glDeleteBuffers(n, buffers);
+        checkError();
+    }
+
+    public void glDrawElements(int mode, int count, int type, int offset) {
+        checkThread();
+        mgl11.glDrawElements(mode, count, type, offset);
+        checkError();
+    }
+
+    public void glGenBuffers(int n, int[] buffers, int offset) {
+        checkThread();
+        mgl11.glGenBuffers(n, buffers, offset);
+        checkError();
+    }
+
+    public void glGenBuffers(int n, IntBuffer buffers) {
+        checkThread();
+        mgl11.glGenBuffers(n, buffers);
+        checkError();
+    }
+
+    public void glGetBooleanv(int pname, boolean[] params, int offset) {
+        checkThread();
+        mgl11.glGetBooleanv(pname, params, offset);
+        checkError();
+    }
+
+    public void glGetBooleanv(int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetBooleanv(pname, params);
+        checkError();
+    }
+
+    public void glGetBufferParameteriv(int target, int pname, int[] params,
+            int offset) {
+        checkThread();
+        mgl11.glGetBufferParameteriv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetBufferParameteriv(target, pname, params);
+        checkError();
+    }
+
+    public void glGetClipPlanef(int pname, float[] eqn, int offset) {
+        checkThread();
+        mgl11.glGetClipPlanef(pname, eqn, offset);
+        checkError();
+    }
+
+    public void glGetClipPlanef(int pname, FloatBuffer eqn) {
+        checkThread();
+        mgl11.glGetClipPlanef(pname, eqn);
+        checkError();
+    }
+
+    public void glGetClipPlanex(int pname, int[] eqn, int offset) {
+        checkThread();
+        mgl11.glGetClipPlanex(pname, eqn, offset);
+        checkError();
+    }
+
+    public void glGetClipPlanex(int pname, IntBuffer eqn) {
+        checkThread();
+        mgl11.glGetClipPlanex(pname, eqn);
+        checkError();
+    }
+
+    public void glGetFixedv(int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glGetFixedv(pname, params, offset);
+        checkError();
+    }
+
+    public void glGetFixedv(int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetFixedv(pname, params);
+        checkError();
+    }
+
+    public void glGetFloatv(int pname, float[] params, int offset) {
+        checkThread();
+        mgl11.glGetFloatv(pname, params, offset);
+        checkError();
+    }
+
+    public void glGetFloatv(int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glGetFloatv(pname, params);
+        checkError();
+    }
+
+    public void glGetLightfv(int light, int pname, float[] params, int offset) {
+        checkThread();
+        mgl11.glGetLightfv(light, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetLightfv(int light, int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glGetLightfv(light, pname, params);
+        checkError();
+    }
+
+    public void glGetLightxv(int light, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glGetLightxv(light, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetLightxv(int light, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetLightxv(light, pname, params);
+        checkError();
+    }
+
+    public void glGetMaterialfv(int face, int pname, float[] params, int offset) {
+        checkThread();
+        mgl11.glGetMaterialfv(face, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetMaterialfv(int face, int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glGetMaterialfv(face, pname, params);
+        checkError();
+    }
+
+    public void glGetMaterialxv(int face, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glGetMaterialxv(face, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetMaterialxv(int face, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetMaterialxv(face, pname, params);
+        checkError();
+    }
+
+    public void glGetPointerv(int pname, Buffer[] params) {
+        checkThread();
+        mgl11.glGetPointerv(pname, params);
+        checkError();
+    }
+
+    public void glGetTexEnviv(int env, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glGetTexEnviv(env, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetTexEnviv(int env, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetTexEnviv(env, pname, params);
+        checkError();
+    }
+
+    public void glGetTexEnvxv(int env, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glGetTexEnvxv(env, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetTexEnvxv(int env, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetTexEnvxv(env, pname, params);
+        checkError();
+    }
+
+    public void glGetTexParameterfv(int target, int pname, float[] params,
+            int offset) {
+        checkThread();
+        mgl11.glGetTexParameterfv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glGetTexParameterfv(target, pname, params);
+        checkError();
+    }
+
+    public void glGetTexParameteriv(int target, int pname, int[] params,
+            int offset) {
+        checkThread();
+        mgl11.glGetTexParameteriv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetTexParameteriv(target, pname, params);
+        checkError();
+    }
+
+    public void glGetTexParameterxv(int target, int pname, int[] params,
+            int offset) {
+        checkThread();
+        mgl11.glGetTexParameterxv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glGetTexParameterxv(int target, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glGetTexParameterxv(target, pname, params);
+        checkError();
+    }
+
+    public boolean glIsBuffer(int buffer) {
+        checkThread();
+        boolean valid = mgl11.glIsBuffer(buffer);
+        checkError();
+        return valid;
+    }
+
+    public boolean glIsEnabled(int cap) {
+        checkThread();
+        boolean valid = mgl11.glIsEnabled(cap);
+        checkError();
+        return valid;
+    }
+
+    public boolean glIsTexture(int texture) {
+        checkThread();
+        boolean valid = mgl11.glIsTexture(texture);
+        checkError();
+        return valid;
+    }
+
+    public void glNormalPointer(int type, int stride, int offset) {
+        checkThread();
+        mgl11.glNormalPointer(type, stride, offset);
+        checkError();
+    }
+
+    public void glPointParameterf(int pname, float param) {
+        checkThread();
+        mgl11.glPointParameterf(pname, param);
+        checkError();
+    }
+
+    public void glPointParameterfv(int pname, float[] params, int offset) {
+        checkThread();
+        mgl11.glPointParameterfv(pname, params, offset);
+        checkError();
+    }
+
+    public void glPointParameterfv(int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glPointParameterfv(pname, params);
+        checkError();
+    }
+
+    public void glPointParameterx(int pname, int param) {
+        checkThread();
+        mgl11.glPointParameterx(pname, param);
+        checkError();
+    }
+
+    public void glPointParameterxv(int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glPointParameterxv(pname, params, offset);
+        checkError();
+    }
+
+    public void glPointParameterxv(int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glPointParameterxv(pname, params);
+        checkError();
+    }
+
+    public void glPointSizePointerOES(int type, int stride, Buffer pointer) {
+        checkThread();
+        mgl11.glPointSizePointerOES(type, stride, pointer);
+        checkError();
+    }
+
+    public void glTexCoordPointer(int size, int type, int stride, int offset) {
+        checkThread();
+        mgl11.glTexCoordPointer(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glTexEnvi(int target, int pname, int param) {
+        checkThread();
+        mgl11.glTexEnvi(target, pname, param);
+        checkError();
+    }
+
+    public void glTexEnviv(int target, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glTexEnviv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glTexEnviv(int target, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glTexEnviv(target, pname, params);
+        checkError();
+    }
+
+    public void glTexParameterfv(int target, int pname, float[] params,
+            int offset) {
+        checkThread();
+        mgl11.glTexParameterfv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glTexParameterfv(int target, int pname, FloatBuffer params) {
+        checkThread();
+        mgl11.glTexParameterfv(target, pname, params);
+        checkError();
+    }
+
+    public void glTexParameteri(int target, int pname, int param) {
+        checkThread();
+        mgl11.glTexParameteri(target, pname, param);
+        checkError();
+    }
+
+    public void glTexParameterxv(int target, int pname, int[] params, int offset) {
+        checkThread();
+        mgl11.glTexParameterxv(target, pname, params, offset);
+        checkError();
+    }
+
+    public void glTexParameterxv(int target, int pname, IntBuffer params) {
+        checkThread();
+        mgl11.glTexParameterxv(target, pname, params);
+        checkError();
+    }
+
+    public void glVertexPointer(int size, int type, int stride, int offset) {
+        checkThread();
+        mgl11.glVertexPointer(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glCurrentPaletteMatrixOES(int matrixpaletteindex) {
+        checkThread();
+        mgl11Ext.glCurrentPaletteMatrixOES(matrixpaletteindex);
+        checkError();
+    }
+
+    public void glLoadPaletteFromModelViewMatrixOES() {
+        checkThread();
+        mgl11Ext.glLoadPaletteFromModelViewMatrixOES();
+        checkError();
+    }
+
+    public void glMatrixIndexPointerOES(int size, int type, int stride,
+            Buffer pointer) {
+        checkThread();
+        mgl11Ext.glMatrixIndexPointerOES(size, type, stride, pointer);
+        checkError();
+    }
+
+    public void glMatrixIndexPointerOES(int size, int type, int stride,
+            int offset) {
+        checkThread();
+        mgl11Ext.glMatrixIndexPointerOES(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glWeightPointerOES(int size, int type, int stride,
+            Buffer pointer) {
+        checkThread();
+        mgl11Ext.glWeightPointerOES(size, type, stride, pointer);
+        checkError();
+    }
+
+    public void glWeightPointerOES(int size, int type, int stride, int offset) {
+        checkThread();
+        mgl11Ext.glWeightPointerOES(size, type, stride, offset);
+        checkError();
+    }
+
+
 }
diff --git a/opengl/java/android/opengl/GLLogWrapper.java b/opengl/java/android/opengl/GLLogWrapper.java
index f332448..6e97f67 100644
--- a/opengl/java/android/opengl/GLLogWrapper.java
+++ b/opengl/java/android/opengl/GLLogWrapper.java
@@ -932,83 +932,83 @@ class GLLogWrapper extends GLWrapperBase {
         boolean convertWholeBuffer = (byteCount < 0);
         if (input instanceof ByteBuffer) {
             ByteBuffer input2 = (ByteBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit();
+                byteCount = input2.limit() - position;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
-            int position = input2.position();
             for (int i = 0; i < byteCount; i++) {
                 result.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof CharBuffer) {
             CharBuffer input2 = (CharBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 2;
+                byteCount = (input2.limit() - position) * 2;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             CharBuffer result2 = result.asCharBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 2; i++) {
                 result2.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof ShortBuffer) {
             ShortBuffer input2 = (ShortBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 2;
+                byteCount = (input2.limit() - position)* 2;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             ShortBuffer result2 = result.asShortBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 2; i++) {
                 result2.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof IntBuffer) {
             IntBuffer input2 = (IntBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 4;
+                byteCount = (input2.limit() - position) * 4;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             IntBuffer result2 = result.asIntBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 4; i++) {
                 result2.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof FloatBuffer) {
             FloatBuffer input2 = (FloatBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 4;
+                byteCount = (input2.limit() - position) * 4;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             FloatBuffer result2 = result.asFloatBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 4; i++) {
                 result2.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof DoubleBuffer) {
             DoubleBuffer input2 = (DoubleBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 8;
+                byteCount = (input2.limit() - position) * 8;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             DoubleBuffer result2 = result.asDoubleBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 8; i++) {
                 result2.put(input2.get());
             }
             input2.position(position);
         } else if (input instanceof LongBuffer) {
             LongBuffer input2 = (LongBuffer) input;
+            int position = input2.position();
             if (convertWholeBuffer) {
-                byteCount = input2.limit() * 8;
+                byteCount = (input2.limit() - position) * 8;
             }
             result = ByteBuffer.allocate(byteCount).order(input2.order());
             LongBuffer result2 = result.asLongBuffer();
-            int position = input2.position();
             for (int i = 0; i < byteCount / 8; i++) {
                 result2.put(input2.get());
             }
@@ -1064,8 +1064,8 @@ class GLLogWrapper extends GLWrapperBase {
         }
         builder.append(" ");
         builder.append(name + ":{");
-        if (pointer == null) {
-            builder.append("undefined");
+        if (pointer == null || pointer.mTempByteBuffer == null ) {
+            builder.append("undefined }");
             return;
         }
         if (pointer.mStride < 0) {
@@ -2767,230 +2767,684 @@ class GLLogWrapper extends GLWrapperBase {
         return valid;
     }
 
-    // Unsupported GL11 methods
-
     public void glBindBuffer(int target, int buffer) {
-        throw new UnsupportedOperationException();
+        begin("glBindBuffer");
+        arg("target", target);
+        arg("buffer", buffer);
+        end();
+        mgl11.glBindBuffer(target, buffer);
+        checkError();
     }
 
     public void glBufferData(int target, int size, Buffer data, int usage) {
-        throw new UnsupportedOperationException();
+        begin("glBufferData");
+        arg("target", target);
+        arg("size", size);
+        arg("data", data.toString());
+        arg("usage", usage);
+        end();
+        mgl11.glBufferData(target, size, data, usage);
+        checkError();
     }
 
     public void glBufferSubData(int target, int offset, int size, Buffer data) {
-        throw new UnsupportedOperationException();
+        begin("glBufferSubData");
+        arg("target", target);
+        arg("offset", offset);
+        arg("size", size);
+        arg("data", data.toString());
+        end();
+        mgl11.glBufferSubData(target, offset, size, data);
+        checkError();
     }
 
     public void glColor4ub(byte red, byte green, byte blue, byte alpha) {
-        throw new UnsupportedOperationException();
+        begin("glColor4ub");
+        arg("red", red);
+        arg("green", green);
+        arg("blue", blue);
+        arg("alpha", alpha);
+        end();
+        mgl11.glColor4ub(red, green, blue, alpha);
+        checkError();
     }
 
     public void glDeleteBuffers(int n, int[] buffers, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glDeleteBuffers");
+        arg("n", n);
+        arg("buffers", buffers.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glDeleteBuffers(n, buffers, offset);
+        checkError();
     }
 
     public void glDeleteBuffers(int n, IntBuffer buffers) {
-        throw new UnsupportedOperationException();
+        begin("glDeleteBuffers");
+        arg("n", n);
+        arg("buffers", buffers.toString());
+        end();
+        mgl11.glDeleteBuffers(n, buffers);
+        checkError();
     }
 
     public void glGenBuffers(int n, int[] buffers, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGenBuffers");
+        arg("n", n);
+        arg("buffers", buffers.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGenBuffers(n, buffers, offset);
+        checkError();
     }
 
     public void glGenBuffers(int n, IntBuffer buffers) {
-        throw new UnsupportedOperationException();
+        begin("glGenBuffers");
+        arg("n", n);
+        arg("buffers", buffers.toString());
+        end();
+        mgl11.glGenBuffers(n, buffers);
+        checkError();
     }
 
     public void glGetBooleanv(int pname, boolean[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetBooleanv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetBooleanv(pname, params, offset);
+        checkError();
     }
 
     public void glGetBooleanv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetBooleanv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetBooleanv(pname, params);
+        checkError();
     }
 
-    public void glGetBufferParameteriv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+    public void glGetBufferParameteriv(int target, int pname, int[] params,
+            int offset) {
+        begin("glGetBufferParameteriv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetBufferParameteriv(target, pname, params, offset);
+        checkError();
     }
 
     public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetBufferParameteriv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetBufferParameteriv(target, pname, params);
+        checkError();
     }
 
     public void glGetClipPlanef(int pname, float[] eqn, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetClipPlanef");
+        arg("pname", pname);
+        arg("eqn", eqn.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetClipPlanef(pname, eqn, offset);
+        checkError();
     }
 
     public void glGetClipPlanef(int pname, FloatBuffer eqn) {
-        throw new UnsupportedOperationException();
+        begin("glGetClipPlanef");
+        arg("pname", pname);
+        arg("eqn", eqn.toString());
+        end();
+        mgl11.glGetClipPlanef(pname, eqn);
+        checkError();
     }
 
     public void glGetClipPlanex(int pname, int[] eqn, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetClipPlanex");
+        arg("pname", pname);
+        arg("eqn", eqn.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetClipPlanex(pname, eqn, offset);
     }
 
     public void glGetClipPlanex(int pname, IntBuffer eqn) {
-        throw new UnsupportedOperationException();
+        begin("glGetClipPlanex");
+        arg("pname", pname);
+        arg("eqn", eqn.toString());
+        end();
+        mgl11.glGetClipPlanex(pname, eqn);
+        checkError();
     }
 
     public void glGetFixedv(int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetFixedv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetFixedv(pname, params, offset);
     }
 
     public void glGetFixedv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetFixedv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetFixedv(pname, params);
+        checkError();
     }
 
     public void glGetFloatv(int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetFloatv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetFloatv(pname, params, offset);
     }
 
     public void glGetFloatv(int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetFloatv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetFloatv(pname, params);
+        checkError();
     }
 
     public void glGetLightfv(int light, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetLightfv");
+        arg("light", light);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetLightfv(light, pname, params, offset);
+        checkError();
     }
 
     public void glGetLightfv(int light, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetLightfv");
+        arg("light", light);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetLightfv(light, pname, params);
+        checkError();
     }
 
     public void glGetLightxv(int light, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetLightxv");
+        arg("light", light);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetLightxv(light, pname, params, offset);
+        checkError();
     }
 
     public void glGetLightxv(int light, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetLightxv");
+        arg("light", light);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetLightxv(light, pname, params);
+        checkError();
     }
 
-    public void glGetMaterialfv(int face, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+    public void glGetMaterialfv(int face, int pname, float[] params,
+            int offset) {
+        begin("glGetMaterialfv");
+        arg("face", face);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetMaterialfv(face, pname, params, offset);
+        checkError();
     }
 
     public void glGetMaterialfv(int face, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetMaterialfv");
+        arg("face", face);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetMaterialfv(face, pname, params);
+        checkError();
     }
 
     public void glGetMaterialxv(int face, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetMaterialxv");
+        arg("face", face);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetMaterialxv(face, pname, params, offset);
+        checkError();
     }
 
     public void glGetMaterialxv(int face, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetMaterialxv");
+        arg("face", face);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetMaterialxv(face, pname, params);
+        checkError();
     }
 
     public void glGetTexEnviv(int env, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexEnviv");
+        arg("env", env);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetTexEnviv(env, pname, params, offset);
+        checkError();
     }
 
     public void glGetTexEnviv(int env, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexEnviv");
+        arg("env", env);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetTexEnviv(env, pname, params);
+        checkError();
     }
 
     public void glGetTexEnvxv(int env, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexEnviv");
+        arg("env", env);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetTexEnviv(env, pname, params, offset);
+        checkError();
     }
 
     public void glGetTexEnvxv(int env, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexEnviv");
+        arg("env", env);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetTexEnvxv(env, pname, params);
+        checkError();
     }
 
     public void glGetTexParameterfv(int target, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexParameterfv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetTexParameterfv(target, pname, params, offset);
+        checkError();
     }
 
     public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexParameterfv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetTexParameterfv(target, pname, params);
+        checkError();
     }
 
     public void glGetTexParameteriv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexParameteriv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetTexEnviv(target, pname, params, offset);
+        checkError();
     }
 
     public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexParameteriv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetTexParameteriv(target, pname, params);
+        checkError();
     }
 
-    public void glGetTexParameterxv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+    public void glGetTexParameterxv(int target, int pname, int[] params,
+            int offset) {
+        begin("glGetTexParameterxv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glGetTexParameterxv(target, pname, params, offset);
+        checkError();
     }
 
     public void glGetTexParameterxv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glGetTexParameterxv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetTexParameterxv(target, pname, params);
+        checkError();
     }
 
     public boolean glIsBuffer(int buffer) {
-        throw new UnsupportedOperationException();
+        begin("glIsBuffer");
+        arg("buffer", buffer);
+        end();
+        boolean result = mgl11.glIsBuffer(buffer);
+        checkError();
+        return result;
     }
 
     public boolean glIsEnabled(int cap) {
-        throw new UnsupportedOperationException();
+        begin("glIsEnabled");
+        arg("cap", cap);
+        end();
+        boolean result = mgl11.glIsEnabled(cap);
+        checkError();
+        return result;
     }
 
     public boolean glIsTexture(int texture) {
-        throw new UnsupportedOperationException();
+        begin("glIsTexture");
+        arg("texture", texture);
+        end();
+        boolean result = mgl11.glIsTexture(texture);
+        checkError();
+        return result;
     }
 
     public void glPointParameterf(int pname, float param) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterf");
+        arg("pname", pname);
+        arg("param", param);
+        end();
+        mgl11.glPointParameterf( pname, param);
+        checkError();
     }
 
     public void glPointParameterfv(int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterfv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glPointParameterfv(pname, params, offset);
+        checkError();
     }
 
     public void glPointParameterfv(int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterfv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glPointParameterfv(pname, params);
+        checkError();
     }
 
     public void glPointParameterx(int pname, int param) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterfv");
+        arg("pname", pname);
+        arg("param", param);
+        end();
+        mgl11.glPointParameterx( pname, param);
+        checkError();
     }
 
     public void glPointParameterxv(int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterxv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glPointParameterxv(pname, params, offset);
+        checkError();
     }
 
     public void glPointParameterxv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glPointParameterxv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glPointParameterxv( pname, params);
+        checkError();
     }
 
     public void glPointSizePointerOES(int type, int stride, Buffer pointer) {
-        throw new UnsupportedOperationException();
+        begin("glPointSizePointerOES");
+        arg("type", type);
+        arg("stride", stride);
+        arg("params", pointer.toString());
+        end();
+        mgl11.glPointSizePointerOES( type, stride, pointer);
+        checkError();
     }
 
     public void glTexEnvi(int target, int pname, int param) {
-        throw new UnsupportedOperationException();
+        begin("glTexEnvi");
+        arg("target", target);
+        arg("pname", pname);
+        arg("param", param);
+        end();
+        mgl11.glTexEnvi(target, pname, param);
+        checkError();
     }
 
     public void glTexEnviv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+        begin("glTexEnviv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glTexEnviv(target, pname, params, offset);
+        checkError();
     }
 
     public void glTexEnviv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glTexEnviv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glTexEnviv( target, pname, params);
+        checkError();
     }
 
-    public void glTexParameterfv(int target, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
+    public void glTexParameterfv(int target, int pname, float[] params,
+            int offset) {
+        begin("glTexParameterfv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glTexParameterfv( target, pname, params, offset);
+        checkError();
     }
 
     public void glTexParameterfv(int target, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glTexParameterfv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glTexParameterfv(target, pname, params);
+        checkError();
     }
 
     public void glTexParameteri(int target, int pname, int param) {
-        throw new UnsupportedOperationException();
+        begin("glTexParameterxv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("param", param);
+        end();
+        mgl11.glTexParameteri(target, pname, param);
+        checkError();
     }
 
-    public void glTexParameterxv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
+    public void glTexParameterxv(int target, int pname, int[] params,
+            int offset) {
+        begin("glTexParameterxv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        arg("offset", offset);
+        end();
+        mgl11.glTexParameterxv(target, pname, params, offset);
+        checkError();
     }
 
     public void glTexParameterxv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
+        begin("glTexParameterxv");
+        arg("target", target);
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glTexParameterxv(target, pname, params);
+        checkError();
+    }
+
+
+    public void glColorPointer(int size, int type, int stride, int offset) {
+        begin("glColorPointer");
+        arg("size", size);
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11.glColorPointer(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glDrawElements(int mode, int count, int type, int offset) {
+        begin("glDrawElements");
+        arg("mode", mode);
+        arg("count", count);
+        arg("type", type);
+        arg("offset", offset);
+        end();
+        mgl11.glDrawElements(mode, count, type, offset);
+        checkError();
+    }
+
+    public void glGetPointerv(int pname, Buffer[] params) {
+        begin("glGetPointerv");
+        arg("pname", pname);
+        arg("params", params.toString());
+        end();
+        mgl11.glGetPointerv(pname, params);
+        checkError();
+    }
+
+    public void glNormalPointer(int type, int stride, int offset) {
+        begin("glNormalPointer");
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11.glNormalPointer(type, stride, offset);
+    }
+
+    public void glTexCoordPointer(int size, int type, int stride, int offset) {
+        begin("glTexCoordPointer");
+        arg("size", size);
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11.glTexCoordPointer(size, type, stride, offset);
+    }
+
+    public void glVertexPointer(int size, int type, int stride, int offset) {
+        begin("glVertexPointer");
+        arg("size", size);
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11.glVertexPointer(size, type, stride, offset);
+    }
+
+    public void glCurrentPaletteMatrixOES(int matrixpaletteindex) {
+        begin("glCurrentPaletteMatrixOES");
+        arg("matrixpaletteindex", matrixpaletteindex);
+        end();
+        mgl11Ext.glCurrentPaletteMatrixOES(matrixpaletteindex);
+        checkError();
+    }
+
+    public void glLoadPaletteFromModelViewMatrixOES() {
+        begin("glLoadPaletteFromModelViewMatrixOES");
+        end();
+        mgl11Ext.glLoadPaletteFromModelViewMatrixOES();
+        checkError();
+    }
+
+    public void glMatrixIndexPointerOES(int size, int type, int stride,
+            Buffer pointer) {
+        begin("glMatrixIndexPointerOES");
+        argPointer(size, type, stride, pointer);
+        end();
+        mgl11Ext.glMatrixIndexPointerOES(size, type, stride, pointer);
+        checkError();
+    }
+
+    public void glMatrixIndexPointerOES(int size, int type, int stride,
+            int offset) {
+        begin("glMatrixIndexPointerOES");
+        arg("size", size);
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11Ext.glMatrixIndexPointerOES(size, type, stride, offset);
+        checkError();
+    }
+
+    public void glWeightPointerOES(int size, int type, int stride,
+            Buffer pointer) {
+        begin("glWeightPointerOES");
+        argPointer(size, type, stride, pointer);
+        end();
+        mgl11Ext.glWeightPointerOES(size, type, stride, pointer);
+        checkError();
+    }
+
+    public void glWeightPointerOES(int size, int type, int stride, int offset) {
+        begin("glWeightPointerOES");
+        arg("size", size);
+        arg("type", type);
+        arg("stride", stride);
+        arg("offset", offset);
+        end();
+        mgl11Ext.glWeightPointerOES(size, type, stride, offset);
+        checkError();
     }
 
     private class PointerInfo {
@@ -3010,6 +3464,9 @@ class GLLogWrapper extends GLWrapperBase {
         public Buffer mPointer;
         public ByteBuffer mTempByteBuffer; // Only valid during glDrawXXX calls
 
+        public PointerInfo() {
+        }
+
         public PointerInfo(int size, int type, int stride, Buffer pointer) {
             mSize = size;
             mType = type;
@@ -3039,7 +3496,7 @@ class GLLogWrapper extends GLWrapperBase {
         }
 
         public void bindByteBuffer() {
-            mTempByteBuffer = toByteBuffer(-1, mPointer);
+            mTempByteBuffer = mPointer == null ? null : toByteBuffer(-1, mPointer);
         }
 
         public void unbindByteBuffer() {
@@ -3051,10 +3508,10 @@ class GLLogWrapper extends GLWrapperBase {
     private boolean mLogArgumentNames;
     private int mArgCount;
 
-    private PointerInfo mColorPointer;
-    private PointerInfo mNormalPointer;
-    private PointerInfo mTexCoordPointer;
-    private PointerInfo mVertexPointer;
+    private PointerInfo mColorPointer = new PointerInfo();
+    private PointerInfo mNormalPointer = new PointerInfo();
+    private PointerInfo mTexCoordPointer = new PointerInfo();
+    private PointerInfo mVertexPointer = new PointerInfo();
 
     boolean mColorArrayEnabled;
     boolean mNormalArrayEnabled;
diff --git a/opengl/java/android/opengl/GLSurfaceView.java b/opengl/java/android/opengl/GLSurfaceView.java
index c458a7a..185398b 100644
--- a/opengl/java/android/opengl/GLSurfaceView.java
+++ b/opengl/java/android/opengl/GLSurfaceView.java
@@ -398,7 +398,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
      * {@link #setEGLConfigChooser(EGLConfigChooser)} has been called, then the supplied
      * EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible config.
      * @param version The EGLContext client version to choose. Use 2 for OpenGL ES 2.0
-     * @hide
      */
     public void setEGLContextClientVersion(int version) {
         checkRenderThreadState();
diff --git a/opengl/java/android/opengl/GLU.java b/opengl/java/android/opengl/GLU.java
index 49a43d0..ed64556 100644
--- a/opengl/java/android/opengl/GLU.java
+++ b/opengl/java/android/opengl/GLU.java
@@ -72,60 +72,12 @@ public class GLU {
             float centerX, float centerY, float centerZ, float upX, float upY,
             float upZ) {
 
-        // See the OpenGL GLUT documentation for gluLookAt for a description
-        // of the algorithm. We implement it in a straightforward way:
-
-        float fx = centerX - eyeX;
-        float fy = centerY - eyeY;
-        float fz = centerZ - eyeZ;
-
-        // Normalize f
-        float rlf = 1.0f / Matrix.length(fx, fy, fz);
-        fx *= rlf;
-        fy *= rlf;
-        fz *= rlf;
-
-        // compute s = f x up (x means "cross product")
-        float sx = fy * upZ - fz * upY;
-        float sy = fz * upX - fx * upZ;
-        float sz = fx * upY - fy * upX;
-
-        // and normalize s
-        float rls = 1.0f / Matrix.length(sx, sy, sz);
-        sx *= rls;
-        sy *= rls;
-        sz *= rls;
-
-        // compute u = s x f
-        float ux = sy * fz - sz * fy;
-        float uy = sz * fx - sx * fz;
-        float uz = sx * fy - sy * fx;
-
         float[] scratch = sScratch;
         synchronized(scratch) {
-            scratch[0] = sx;
-            scratch[1] = ux;
-            scratch[2] = -fx;
-            scratch[3] = 0.0f;
-
-            scratch[4] = sy;
-            scratch[5] = uy;
-            scratch[6] = -fy;
-            scratch[7] = 0.0f;
-
-            scratch[8] = sz;
-            scratch[9] = uz;
-            scratch[10] = -fz;
-            scratch[11] = 0.0f;
-
-            scratch[12] = 0.0f;
-            scratch[13] = 0.0f;
-            scratch[14] = 0.0f;
-            scratch[15] = 1.0f;
-
+            Matrix.setLookAtM(scratch, 0, eyeX, eyeY, eyeZ, centerX, centerY, centerZ,
+                    upX, upY, upZ);
             gl.glMultMatrixf(scratch, 0);
         }
-        gl.glTranslatef(-eyeX, -eyeY, -eyeZ);
     }
 
     /**
diff --git a/opengl/java/android/opengl/GLWrapperBase.java b/opengl/java/android/opengl/GLWrapperBase.java
index 067f95f..b0f83f7 100644
--- a/opengl/java/android/opengl/GLWrapperBase.java
+++ b/opengl/java/android/opengl/GLWrapperBase.java
@@ -16,9 +16,6 @@
 
 package android.opengl;
 
-import java.nio.Buffer;
-import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
 import javax.microedition.khronos.opengles.GL;
 import javax.microedition.khronos.opengles.GL10;
 import javax.microedition.khronos.opengles.GL10Ext;
@@ -32,464 +29,25 @@ import javax.microedition.khronos.opengles.GL11ExtensionPack;
  */
 abstract class GLWrapperBase
     implements GL, GL10, GL10Ext, GL11, GL11Ext {
-	public GLWrapperBase(GL gl) {
-		mgl = (GL10) gl;
-		if (gl instanceof GL10Ext) {
-			mgl10Ext = (GL10Ext) gl;
-		}
-		if (gl instanceof GL11) {
-			mgl11 = (GL11) gl;
-		}
-		if (gl instanceof GL11Ext) {
-			mgl11Ext = (GL11Ext) gl;
-		}
-		if (gl instanceof GL11ExtensionPack) {
-			mgl11ExtensionPack = (GL11ExtensionPack) gl;
-		}
-	}
-	
-	protected GL10 mgl;
-	protected GL10Ext mgl10Ext;
-	protected GL11 mgl11;
-	protected GL11Ext mgl11Ext;
-	protected GL11ExtensionPack mgl11ExtensionPack;
-
-    // Unsupported GL11 methods
-
-    public void glGetPointerv(int pname, java.nio.Buffer[] params) {
-        throw new UnsupportedOperationException();
-    }
-
-    // VBO versions of *Pointer and *Elements methods
-    public void glColorPointer(int size, int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glNormalPointer(int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexCoordPointer(int size, int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glVertexPointer(int size, int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDrawElements(int mode, int count, int type, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBindBuffer(int target, int buffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBufferData(int target, int size, Buffer data, int usage) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBufferSubData(int target, int offset, int size, Buffer data) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glColor4ub(byte red, byte green, byte blue, byte alpha) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteBuffers(int n, int[] buffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteBuffers(int n, IntBuffer buffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenBuffers(int n, int[] buffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenBuffers(int n, IntBuffer buffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetBooleanv(int pname, boolean[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetBooleanv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetBufferParameteriv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetClipPlanef(int pname, float[] eqn, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetClipPlanef(int pname, FloatBuffer eqn) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetClipPlanex(int pname, int[] eqn, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetClipPlanex(int pname, IntBuffer eqn) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFixedv(int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFixedv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFloatv(int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFloatv(int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetLightfv(int light, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetLightfv(int light, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetLightxv(int light, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetLightxv(int light, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetMaterialfv(int face, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetMaterialfv(int face, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetMaterialxv(int face, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetMaterialxv(int face, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexEnviv(int env, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexEnviv(int env, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexEnvxv(int env, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexEnvxv(int env, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameterfv(int target, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameteriv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameterxv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexParameterxv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public boolean glIsBuffer(int buffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public boolean glIsEnabled(int cap) {
-        throw new UnsupportedOperationException();
-    }
-
-    public boolean glIsTexture(int texture) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterf(int pname, float param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterfv(int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterfv(int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterx(int pname, int param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterxv(int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointParameterxv(int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glPointSizePointerOES(int type, int stride, Buffer pointer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexEnvi(int target, int pname, int param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexEnviv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexEnviv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexParameterfv(int target, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexParameterfv(int target, int pname, FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexParameteri(int target, int pname, int param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexParameterxv(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexParameterxv(int target, int pname, IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    // Unsupported GL11Ext methods
-
-    public void glCurrentPaletteMatrixOES(int matrixpaletteindex) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glLoadPaletteFromModelViewMatrixOES() {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glMatrixIndexPointerOES(int size, int type, int stride, Buffer pointer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glMatrixIndexPointerOES(int size, int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glWeightPointerOES(int size, int type, int stride, Buffer pointer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glWeightPointerOES(int size, int type, int stride, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    // Unsupported GL11ExtensionPack methods
-
-    public void glBindFramebufferOES(int target, int framebuffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBindRenderbufferOES(int target, int renderbuffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBlendEquation(int mode) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
-        throw new UnsupportedOperationException();
-    }
-
-    int glCheckFramebufferStatusOES(int target) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, int imageSize) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteFramebuffersOES(int n, int[] framebuffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteFramebuffersOES(int n, java.nio.IntBuffer framebuffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteRenderbuffersOES(int n, int[] renderbuffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glDeleteRenderbuffersOES(int n, java.nio.IntBuffer renderbuffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glFramebufferRenderbufferOES(int target, int attachment, int renderbuffertarget, int renderbuffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glFramebufferTexture2DOES(int target, int attachment, int textarget, int texture, int level) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenerateMipmapOES(int target) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenFramebuffersOES(int n, int[] framebuffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenFramebuffersOES(int n, java.nio.IntBuffer framebuffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenRenderbuffersOES(int n, int[] renderbuffers, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGenRenderbuffersOES(int n, java.nio.IntBuffer renderbuffers) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFramebufferAttachmentParameterivOES(int target, int attachment, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetFramebufferAttachmentParameterivOES(int target, int attachment, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetRenderbufferParameterivOES(int target, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetRenderbufferParameterivOES(int target, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGenfv(int coord, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGenfv(int coord, int pname, java.nio.FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGeniv(int coord, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGeniv(int coord, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGenxv(int coord, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glGetTexGenxv(int coord, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public boolean glIsFramebufferOES(int framebuffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public boolean glIsRenderbufferOES(int renderbuffer) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glRenderbufferStorageOES(int target, int internalformat, int width, int height) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenf(int coord, int pname, float param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenfv(int coord, int pname, float[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenfv(int coord, int pname, java.nio.FloatBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGeni(int coord, int pname, int param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGeniv(int coord, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGeniv(int coord, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenx(int coord, int pname, int param) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenxv(int coord, int pname, int[] params, int offset) {
-        throw new UnsupportedOperationException();
-    }
-
-    public void glTexGenxv(int coord, int pname, java.nio.IntBuffer params) {
-        throw new UnsupportedOperationException();
-    }
+    public GLWrapperBase(GL gl) {
+        mgl = (GL10) gl;
+        if (gl instanceof GL10Ext) {
+            mgl10Ext = (GL10Ext) gl;
+        }
+        if (gl instanceof GL11) {
+            mgl11 = (GL11) gl;
+        }
+        if (gl instanceof GL11Ext) {
+            mgl11Ext = (GL11Ext) gl;
+        }
+        if (gl instanceof GL11ExtensionPack) {
+            mgl11ExtensionPack = (GL11ExtensionPack) gl;
+        }
+    }
+
+    protected GL10 mgl;
+    protected GL10Ext mgl10Ext;
+    protected GL11 mgl11;
+    protected GL11Ext mgl11Ext;
+    protected GL11ExtensionPack mgl11ExtensionPack;
 }
diff --git a/opengl/java/android/opengl/Matrix.java b/opengl/java/android/opengl/Matrix.java
index 13ba36e..b9fd4ab 100644
--- a/opengl/java/android/opengl/Matrix.java
+++ b/opengl/java/android/opengl/Matrix.java
@@ -16,6 +16,8 @@
 
 package android.opengl;
 
+import javax.microedition.khronos.opengles.GL10;
+
 /**
  * Matrix math utilities. These methods operate on OpenGL ES format
  * matrices and vectors stored in float arrays.
@@ -582,4 +584,77 @@ public class Matrix {
         rm[rmOffset + 14] =  0.0f;
         rm[rmOffset + 15] =  1.0f;
     }
+
+    /**
+     * Define a viewing transformation in terms of an eye point, a center of
+     * view, and an up vector.
+     *
+     * @param rm returns the result
+     * @param rmOffset index into rm where the result matrix starts
+     * @param eyeX eye point X
+     * @param eyeY eye point Y
+     * @param eyeZ eye point Z
+     * @param centerX center of view X
+     * @param centerY center of view Y
+     * @param centerZ center of view Z
+     * @param upX up vector X
+     * @param upY up vector Y
+     * @param upZ up vector Z
+     */
+    public static void setLookAtM(float[] rm, int rmOffset,
+            float eyeX, float eyeY, float eyeZ,
+            float centerX, float centerY, float centerZ, float upX, float upY,
+            float upZ) {
+
+        // See the OpenGL GLUT documentation for gluLookAt for a description
+        // of the algorithm. We implement it in a straightforward way:
+
+        float fx = centerX - eyeX;
+        float fy = centerY - eyeY;
+        float fz = centerZ - eyeZ;
+
+        // Normalize f
+        float rlf = 1.0f / Matrix.length(fx, fy, fz);
+        fx *= rlf;
+        fy *= rlf;
+        fz *= rlf;
+
+        // compute s = f x up (x means "cross product")
+        float sx = fy * upZ - fz * upY;
+        float sy = fz * upX - fx * upZ;
+        float sz = fx * upY - fy * upX;
+
+        // and normalize s
+        float rls = 1.0f / Matrix.length(sx, sy, sz);
+        sx *= rls;
+        sy *= rls;
+        sz *= rls;
+
+        // compute u = s x f
+        float ux = sy * fz - sz * fy;
+        float uy = sz * fx - sx * fz;
+        float uz = sx * fy - sy * fx;
+
+        rm[rmOffset + 0] = sx;
+        rm[rmOffset + 1] = ux;
+        rm[rmOffset + 2] = -fx;
+        rm[rmOffset + 3] = 0.0f;
+
+        rm[rmOffset + 4] = sy;
+        rm[rmOffset + 5] = uy;
+        rm[rmOffset + 6] = -fy;
+        rm[rmOffset + 7] = 0.0f;
+
+        rm[rmOffset + 8] = sz;
+        rm[rmOffset + 9] = uz;
+        rm[rmOffset + 10] = -fz;
+        rm[rmOffset + 11] = 0.0f;
+
+        rm[rmOffset + 12] = 0.0f;
+        rm[rmOffset + 13] = 0.0f;
+        rm[rmOffset + 14] = 0.0f;
+        rm[rmOffset + 15] = 1.0f;
+
+        translateM(rm, rmOffset, -eyeX, -eyeY, -eyeZ);
+    }
 }