@@ -25,6 +25,7 @@
 
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
 
 import javax.microedition.khronos.egl.EGL10;
 import javax.microedition.khronos.egl.EGLConfig;
@@ -380,8 +381,8 @@ public boolean contextIsCurrent(Context other) {
   }  
 
   static public short makeIndex(int intIdx) {
-    // When the index value is greater than 32767 subtracting 65536
-    // will make it as a short to wrap around to the negative range, which    
+    // When the index value is greater than 32767, subtracting 65536
+    // will make it (as a short) to wrap around to the negative range, which    
     // is all we need to later pass these numbers to opengl (which will 
     // interpret them as unsigned shorts). See discussion here:
     // http://stackoverflow.com/questions/4331021/java-opengl-gldrawelements-with-32767-vertices
@@ -396,6 +397,30 @@ public void disableTexturing(int target) {
     //gl.glDisable(target);
   }  
 
+  public void initTexture(int target, int width, int height, int format, int type) {
+    // Doing in patches of 16x16 pixels to avoid creating a (potentially)
+    // very large transient array which in certain situations (memory-
+    // constrained android devices) might lead to an out-of-memory error.
+    int[] texels = new int[16 * 16];
+    for (int y = 0; y < height + 16; y += 16) {
+      int h = PApplet.min(16, height - y);
+      for (int x = 0; x < width + 16; x += 16) {
+        int w = PApplet.min(16, width - x);
+        gl.glTexSubImage2D(target, 0, x, y, w, h, format, type, IntBuffer.wrap(texels));
+      }
+    }
+  }  
+  
+  public String getShaderLog(int id) {
+    int[] compiled = new int[1];
+    GLES20.glGetShaderiv(id, GLES20.GL_COMPILE_STATUS, compiled, 0);
+    if (compiled[0] == 0) {
+      return GLES20.glGetShaderInfoLog(id);
+    } else {
+      return "";
+    }
+  }  
+  
   ///////////////////////////////////////////////////////////////////////////////////
 
   // Frame rendering  
@@ -660,12 +685,12 @@ public void glVertexAttribPointer(int loc, int size, int type, boolean normalize
   }
 
 
-  public ByteBuffer glMapBuffer(int target, int acccess) {  
+  public ByteBuffer glMapBuffer(int target, int access) {  
     //return gl2f.glMapBuffer(GL.GL_ARRAY_BUFFER, GL2.GL_READ_WRITE);
     return null;
   }
 
-  public ByteBuffer glMapBufferRange(int target, int offset, int length, int acccess) {
+  public ByteBuffer glMapBufferRange(int target, int offset, int length, int access) {
     //return gl2x.glMapBufferRange(GL.GL_ARRAY_BUFFER, offset, length, GL2.GL_READ_WRITE);
     return null;
   }
@@ -707,7 +732,7 @@ public void glFramebufferTexture2D(int target, int attachment, int texTarget, in
   }
 
   public void glBindRenderbuffer(int target, int id) {
-    GLES20.glBindRenderbuffer(GLES20.GL_RENDERBUFFER, id);
+    GLES20.glBindRenderbuffer(target, id);
   }
 
   public void glRenderbufferStorageMultisample(int target, int samples, int format, int width, int height) {
@@ -842,16 +867,6 @@ public void glAttachShader(int prog, int shader) {
     GLES20.glAttachShader(prog, shader);  
   }
 
-  public String getShaderLog(int id) {
-    int[] compiled = new int[1];
-    GLES20.glGetShaderiv(id, GLES20.GL_COMPILE_STATUS, compiled, 0);
-    if (compiled[0] == 0) {
-      return GLES20.glGetShaderInfoLog(id);
-    } else {
-      return "";
-    }
-  }
-  
   /////////////////////////////////////////////////////////////////////////////////
 
   // Viewport
@@ -895,7 +910,7 @@ public void setReadBuffer(int buf) {
   }
 
   public void glReadPixels(int x, int y, int width, int height, int format, int type, Buffer buffer) {
-    GLES20.glReadPixels(x, y, width, height, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, buffer);
+    GLES20.glReadPixels(x, y, width, height, format, type, buffer);
   } 
 
   public void setDrawBuffer(int buf) {
 
@@ -907,7 +907,6 @@ public void normal(float nx, float ny, float nz) {
     normalY = ny;
     normalZ = nz;
 
-    /*
     // if drawing a shape and the normal hasn't been set yet,
     // then we need to set the normals for each vertex so far
     if (shape != 0) {
@@ -918,11 +917,9 @@ public void normal(float nx, float ny, float nz) {
         // a separate normal for each vertex
         normalMode = NORMAL_MODE_VERTEX;
       }
-    }
-    */
+    }        
   }
 
-
   /**
    * Set texture mode to either to use coordinates based on the IMAGE
    * (more intuitive for new users) or NORMALIZED (better for advanced chaps)
 
@@ -780,8 +780,6 @@ protected void deleteFinalizedRenderBufferObjects() {
   // GLSL Program Objects -----------------------------------------------
 
   protected int createGLSLProgramObject() {
-    
-    pg.report("before delete");
     deleteFinalizedGLSLProgramObjects();
 
     int id = pgl.glCreateProgram();
@@ -2203,7 +2201,7 @@ public void flush() {
       }          
 
       if (flushMode == FLUSH_WHEN_FULL && !hints[DISABLE_TRANSFORM_CACHE]) {
-        //popMatrix();
+        popMatrix();
       }
     }
 
@@ -6327,7 +6325,7 @@ public void allocate() {
     }
 
     public void trim() {
-      if (vertexCount < vertices.length / 3) {
+      if (0 < vertexCount && vertexCount < vertices.length / 3) {
         trimVertices();
         trimColors();
         trimNormals();
@@ -6337,9 +6335,12 @@ public void trim() {
         trimAmbient();
         trimSpecular();
         trimEmissive();
-        trimShininess();
+        trimShininess();        
+      } 
+      
+      if (0 < edgeCount && edgeCount < edges.length) { 
         trimEdges();
-      }      
+      }
     }
 
     public void dispose() {
@@ -6437,7 +6438,7 @@ public int addVertex(float x, float y, float z,
       index = 3 * vertexCount;
       normals[index++] = nx;
       normals[index++] = ny;
-      normals[index  ] = ny;      
+      normals[index  ] = nz;      
 
       index = 2 * vertexCount;
       texcoords[index++] = u;
@@ -7065,7 +7066,7 @@ public void allocate() {
     }
 
     public void trim() {
-      if (fillVertexCount < fillVertices.length / 3) {
+      if (0 < fillVertexCount && fillVertexCount < fillVertices.length / 3) {
         trimFillVertices();
         trimFillColors();
         trimFillNormals();
@@ -7076,31 +7077,31 @@ public void trim() {
         trimFillShininess();
       }
 
-      if (fillIndexCount < fillIndices.length) {
+      if (0 < fillIndexCount && fillIndexCount < fillIndices.length) {
         trimFillIndices();  
       }
 
-      if (lineVertexCount < lineVertices.length / 3) {
+      if (0 < lineVertexCount && lineVertexCount < lineVertices.length / 3) {
         trimLineVertices();
         trimLineColors();
         trimLineAttributes();
       }
 
-      if (lineIndexCount < lineIndices.length) {
+      if (0 < lineIndexCount && lineIndexCount < lineIndices.length) {
         trimLineIndices();  
       }
 
-      if (pointVertexCount < pointVertices.length / 3) {
+      if (0 < pointVertexCount && pointVertexCount < pointVertices.length / 3) {
         trimPointVertices();
         trimPointColors();
         trimPointAttributes();
       }
 
-      if (pointIndexCount < pointIndices.length) {
+      if (0 < pointIndexCount && pointIndexCount < pointIndices.length) {
         trimPointIndices();  
       }       
     }    
-    
+        
     protected void trimFillVertices() {
       float temp[] = new float[3 * fillVertexCount];      
       PApplet.arrayCopy(fillVertices, 0, temp, 0, 3 * fillVertexCount);
@@ -7174,7 +7175,7 @@ protected void trimLineAttributes() {
     }      
 
     protected void trimLineIndices() {
-      short temp[] = new short[lineVertexCount];      
+      short temp[] = new short[lineIndexCount];      
       PApplet.arrayCopy(lineIndices, 0, temp, 0, lineIndexCount);
       lineIndices = temp;        
     }    
@@ -8571,10 +8572,11 @@ public void tessellatePolygon(boolean solid, boolean closed, boolean calcNormals
 
           // Vertex data includes coordinates, colors, normals, texture coordinates, and material properties.
           double[] vertex = new double[] { in.vertices [3 * i + 0], in.vertices [3 * i + 1], in.vertices[3 * i + 2],
-                                           in.colors   [4 * i + 0], in.colors   [4 * i + 1], in.colors  [4 * i + 2], in.colors[4 * i + 3],
+                                           in.colors   [i],
                                            in.normals  [3 * i + 0], in.normals  [3 * i + 1], in.normals [3 * i + 2],
                                            in.texcoords[2 * i + 0], in.texcoords[2 * i + 1],
                                            in.ambient[i], in.specular[i], in.emissive[i], in.shininess[i] };
+          
           gluTess.addVertex(vertex);
         }        
         gluTess.endContour();
 
@@ -28,6 +28,7 @@
 import java.util.LinkedList;
 import java.util.NoSuchElementException;
 
+
 /**
  * This class wraps an OpenGL texture.
  * By Andres Colubri
@@ -782,20 +783,8 @@ protected void allocate() {
     // from w/h in the case that the GPU doesn't support NPOT textures)
     pgl.glTexImage2D(glTarget, 0, glFormat, glWidth, glHeight, 0, PGL.GL_RGBA, PGL.GL_UNSIGNED_BYTE, null);
 
-    // Once OpenGL knows the size of the new texture, we make sure it doesn't
-    // contain any garbage in the region of interest (0, 0, width, height):        
-    // Doing in patches of 16x16 pixels to avoid creating a (potentially)
-    // very large transient array which in certain situations (memory-
-    // constrained android devices) might lead to an out-of-memory error.
-    int[] texels = new int[16 * 16];
-    for (int y = 0; y < height + 16; y += 16) {
-      int h = PApplet.min(16, height - y);
-      for (int x = 0; x < width + 16; x += 16) {
-        int w = PApplet.min(16, width - x);
-        setTexels(texels, x, y, w, h);        
-      }
-    }
-    texels = null;
+    // Makes sure that the texture buffer in video memory doesn't contain any garbage.
+    pgl.initTexture(glTarget, width, height, PGL.GL_RGBA, PGL.GL_UNSIGNED_BYTE);
 
     pgl.glBindTexture(glTarget, 0);
     pgl.disableTexturing(glTarget);
 
@@ -46,6 +46,15 @@ public interface PConstants {
   static public final int FLUSH_CONTINUOUSLY = 0;
   static public final int FLUSH_WHEN_FULL    = 1;  
 
+  // shaders
+  
+  static public final int FILL_SHADER_SIMPLE = 0;
+  static public final int FILL_SHADER_LIT = 1;
+  static public final int FILL_SHADER_TEX = 2;
+  static public final int FILL_SHADER_FULL = 3;
+  static public final int LINE_SHADER = 4;
+  static public final int POINT_SHADER = 5;  
+  
   // vertex fields
 
   static public final int X = 0;  // model coords xyz (formerly MX/MY/MZ)