PMVMatrix: Defaults from direct NIO -> array-backed non-direct NIO: Reduced cycles 45% -> 5% (from GearsES2 100%)

- NIO direct access from Java is expensive

- default is now array-backed non-direct NIO,
  which guarantees array useage for Java computation (especially the inverse calculation)

- only update Mvi and Mvit if requested in the first place

- moved all local matrices to float[]

4 files changed, 346 insertions, 195 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
index aba6c90a7..a86a2f435 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
@@ -45,7 +45,30 @@ import javax.media.opengl.fixedfunc.GLMatrixFunc;
 
 public class PMVMatrix implements GLMatrixFunc {
 
+    protected final float[] matrixBufferArray;
+
+    /**
+     * Creates an instance of PMVMatrix {@link #PMVMatrix(boolean) PMVMatrix(boolean useBackingArray)},
+     * with <code>useBackingArray = true</code>. 
+     */
     public PMVMatrix() {
+        this(true);
+    }
+    
+    /**
+     * Creates an instance of PMVMatrix.
+     * 
+     * @param useBackingArray <code>true</code> for non direct NIO Buffers with guaranteed backing array,
+     *                        which allows faster access in Java computation.
+     *                        <p><code>false</code> for direct NIO buffers w/o a guaranteed backing array.
+     *                        In most Java implementations, direct NIO buffers have no backing array
+     *                        and hence the Java computation will be throttled down by direct IO get/put 
+     *                        operations.</p> 
+     *                        <p>Depending on the application, ie. weather the Java computation or
+     *                        JNI invocation and hence native data transfer part is heavier, 
+     *                        this flag shall be set to <code>true</code> or <code>false</code></p>.
+     */
+    public PMVMatrix(boolean useBackingArray) {
           projectFloat = new ProjectFloat();
 
           // I    Identity
@@ -54,33 +77,43 @@ public class PMVMatrix implements GLMatrixFunc {
           // Mv   ModelView
           // Mvi  Modelview-Inverse
           // Mvit Modelview-Inverse-Transpose
-          matrixBuffer = Buffers.newDirectByteBuffer(12*16 * Buffers.SIZEOF_FLOAT);
-                                                                   //  I + T + P  + Mv + Mvi + Mvit + Local
-          matrixIdent   = slice2Float(matrixBuffer,  0*16, 1*16);  //  I
-          matrixTex     = slice2Float(matrixBuffer,  1*16, 1*16);  //      T
-          matrixPMvMvit = slice2Float(matrixBuffer,  2*16, 4*16);  //          P  + Mv + Mvi + Mvit
-          matrixPMvMvi  = slice2Float(matrixBuffer,  2*16, 3*16);  //          P  + Mv + Mvi
-          matrixPMv     = slice2Float(matrixBuffer,  2*16, 2*16);  //          P  + Mv
-          matrixP       = slice2Float(matrixBuffer,  2*16, 1*16);  //          P
-          matrixMv      = slice2Float(matrixBuffer,  3*16, 1*16);  //               Mv
-          matrixMvi     = slice2Float(matrixBuffer,  4*16, 1*16);  //                    Mvi
-          matrixMvit    = slice2Float(matrixBuffer,  5*16, 1*16);  //                          Mvit
-          matrixMult    = slice2Float(matrixBuffer,  6*16, 1*16);
-          matrixTrans   = slice2Float(matrixBuffer,  7*16, 1*16);
-          matrixRot     = slice2Float(matrixBuffer,  8*16, 1*16);
-          matrixScale   = slice2Float(matrixBuffer,  9*16, 1*16);
-          matrixOrtho   = slice2Float(matrixBuffer, 10*16, 1*16);
-          matrixFrustum = slice2Float(matrixBuffer, 11*16, 1*16);
-          matrixBuffer.rewind();
+          if(useBackingArray) {
+              matrixBufferArray = new float[6*16];
+              matrixBuffer = null;
+              // matrixBuffer = FloatBuffer.wrap(new float[12*16]);
+          } else {
+              matrixBufferArray = null;
+              matrixBuffer = Buffers.newDirectByteBuffer(6*16 * Buffers.SIZEOF_FLOAT);
+              matrixBuffer.mark();
+          }
           
+          matrixIdent   = slice2Float(matrixBuffer, matrixBufferArray,  0*16, 1*16);  //  I
+          matrixTex     = slice2Float(matrixBuffer, matrixBufferArray,  1*16, 1*16);  //      T
+          matrixPMvMvit = slice2Float(matrixBuffer, matrixBufferArray,  2*16, 4*16);  //          P  + Mv + Mvi + Mvit          
+          matrixPMvMvi  = slice2Float(matrixBuffer, matrixBufferArray,  2*16, 3*16);  //          P  + Mv + Mvi
+          matrixPMv     = slice2Float(matrixBuffer, matrixBufferArray,  2*16, 2*16);  //          P  + Mv
+          matrixP       = slice2Float(matrixBuffer, matrixBufferArray,  2*16, 1*16);  //          P
+          matrixMv      = slice2Float(matrixBuffer, matrixBufferArray,  3*16, 1*16);  //               Mv
+          matrixMvi     = slice2Float(matrixBuffer, matrixBufferArray,  4*16, 1*16);  //                    Mvi
+          matrixMvit    = slice2Float(matrixBuffer, matrixBufferArray,  5*16, 1*16);  //                          Mvit
+          
+          if(null != matrixBuffer) {
+              matrixBuffer.reset();
+          }          
           ProjectFloat.gluMakeIdentityf(matrixIdent);
-          ProjectFloat.gluMakeIdentityf(matrixTrans);
-          ProjectFloat.gluMakeIdentityf(matrixRot);
-          ProjectFloat.gluMakeIdentityf(matrixScale);
-          ProjectFloat.gluMakeIdentityf(matrixOrtho);
-          ProjectFloat.gluMakeZero(matrixFrustum);
-
-          vec3f=new float[3];
+          
+          vec3f         = new float[3];
+          matrixMult    = new float[16];
+          matrixTrans   = new float[16];
+          matrixRot     = new float[16];
+          matrixScale   = new float[16];
+          matrixOrtho   = new float[16];
+          matrixFrustum = new float[16];
+          ProjectFloat.gluMakeIdentityf(matrixTrans, 0);
+          ProjectFloat.gluMakeIdentityf(matrixRot, 0);
+          ProjectFloat.gluMakeIdentityf(matrixScale, 0);
+          ProjectFloat.gluMakeIdentityf(matrixOrtho, 0);
+          ProjectFloat.gluMakeZero(matrixFrustum, 0);
 
           matrixPStack = new ArrayList<float[]>();
           matrixMvStack= new ArrayList<float[]>();
@@ -101,27 +134,30 @@ public class PMVMatrix implements GLMatrixFunc {
             projectFloat.destroy(); projectFloat=null;
         }
 
-        if(null!=matrixBuffer) {
-            matrixBuffer.clear(); matrixBuffer=null;
-        }
-
+        matrixBuffer=null;
+        matrixBuffer=null; matrixPMvMvit=null; matrixPMvMvi=null; matrixPMv=null; 
+        matrixP=null; matrixTex=null; matrixMv=null; matrixMvi=null; matrixMvit=null;        
+
+        vec3f         = null;
+        matrixMult    = null;
+        matrixTrans   = null;
+        matrixRot     = null;
+        matrixScale   = null;
+        matrixOrtho   = null;
+        matrixFrustum = null;
+        
         if(null!=matrixPStack) {
             matrixPStack.clear(); matrixPStack=null;
         }
-        vec3f=null;
         if(null!=matrixMvStack) {
             matrixMvStack.clear(); matrixMvStack=null;
         }
         if(null!=matrixPStack) {
-        matrixPStack.clear(); matrixPStack=null;
+            matrixPStack.clear(); matrixPStack=null;
         }
         if(null!=matrixTStack) {
             matrixTStack.clear(); matrixTStack=null;
         }
-
-        matrixBuffer=null; matrixPMvMvit=null; matrixPMvMvi=null; matrixPMv=null; 
-        matrixP=null; matrixTex=null; matrixMv=null; matrixMvi=null; matrixMvit=null;
-        matrixMult=null; matrixTrans=null; matrixRot=null; matrixScale=null; matrixOrtho=null; matrixFrustum=null;
     }
 
 
@@ -133,14 +169,33 @@ public class PMVMatrix implements GLMatrixFunc {
      * This bug is resolved at least in Android 3.2.
      * 
      * @param buf source ByteBuffer
+     * @param backing source float array
      * @param posFloat {@link Buffers#SIZEOF_FLOAT} position
      * @param lenFloat {@link Buffers#SIZEOF_FLOAT} size 
      * @return FloatBuffer w/ native byte order as given ByteBuffer
      */
-    private static FloatBuffer slice2Float(ByteBuffer buf, int posFloat, int lenFloat) {
-        buf.position( posFloat * Buffers.SIZEOF_FLOAT );
-        buf.limit( (posFloat + lenFloat) * Buffers.SIZEOF_FLOAT );
-        return buf.slice().order(buf.order()).asFloatBuffer(); // slice and duplicate may change byte order        
+    private static FloatBuffer slice2Float(Buffer buf, float[] backing, int posFloat, int lenFloat) {
+        if(buf instanceof ByteBuffer) {
+            ByteBuffer bb = (ByteBuffer) buf;
+            bb.position( posFloat * Buffers.SIZEOF_FLOAT );
+            bb.limit( (posFloat + lenFloat) * Buffers.SIZEOF_FLOAT );
+            FloatBuffer fb = bb.slice().order(bb.order()).asFloatBuffer(); // slice and duplicate may change byte order
+            fb.mark();
+            return fb;
+        } else if(null != backing) {
+            FloatBuffer fb  = FloatBuffer.wrap(backing, posFloat, lenFloat);
+            fb.mark();
+            return fb;
+        } else if(buf instanceof FloatBuffer) {
+            FloatBuffer fb = (FloatBuffer) buf;
+            fb.position( posFloat );
+            fb.limit( posFloat + lenFloat );
+            FloatBuffer fb0 = fb.slice(); // slice and duplicate may change byte order
+            fb0.mark();
+            return fb0;
+        } else {
+            throw new InternalError("XXX");
+        }
     }
 
     public static final boolean isMatrixModeName(final int matrixModeName) {
@@ -231,7 +286,6 @@ public class PMVMatrix implements GLMatrixFunc {
         if(0==modified) return false;
 
         final int res = modified;
-        // int res = DIRTY_MODELVIEW | DIRTY_PROJECTION ;
         if( (res&DIRTY_MODELVIEW)!=0 ) {
             setMviMvit();
         }
@@ -255,11 +309,8 @@ public class PMVMatrix implements GLMatrixFunc {
         return matrixMv;
     }
 
-    public final FloatBuffer glGetPMvMvitMatrixf() {
-        return matrixPMvMvit;
-    }
-
     public final FloatBuffer glGetPMvMviMatrixf() {
+        usesMviMvit |= 1;
         return matrixPMvMvi;
     }
 
@@ -268,9 +319,20 @@ public class PMVMatrix implements GLMatrixFunc {
     }
 
     public final FloatBuffer glGetMviMatrixf() {
+        usesMviMvit |= 1;
         return matrixMvi;
     }
 
+    public final FloatBuffer glGetPMvMvitMatrixf() {
+        usesMviMvit |= 1 | 2;
+        return matrixPMvMvit;
+    }
+    
+    public final FloatBuffer glGetMvitMatrixf() {
+        usesMviMvit |= 1 | 2;
+        return matrixMvit;
+    }
+    
    /*
     * @return the current matrix
     */
@@ -302,22 +364,27 @@ public class PMVMatrix implements GLMatrixFunc {
       glFrustumf(left, right, bottom, top, zNear, zFar);
     }
 
-    public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer p) {
+    public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer d) {
+       final int aP = a.position(); 
+       final int bP = b.position();
+       final int dP = d.position();
        for (int i = 0; i < 4; i++) {
-          final float ai0=a.get(i+0*4),  ai1=a.get(i+1*4),  ai2=a.get(i+2*4),  ai3=a.get(i+3*4);
-          p.put(i+0*4 , ai0 * b.get(0+0*4) + ai1 * b.get(1+0*4) + ai2 * b.get(2+0*4) + ai3 * b.get(3+0*4) );
-          p.put(i+1*4 , ai0 * b.get(0+1*4) + ai1 * b.get(1+1*4) + ai2 * b.get(2+1*4) + ai3 * b.get(3+1*4) );
-          p.put(i+2*4 , ai0 * b.get(0+2*4) + ai1 * b.get(1+2*4) + ai2 * b.get(2+2*4) + ai3 * b.get(3+2*4) );
-          p.put(i+3*4 , ai0 * b.get(0+3*4) + ai1 * b.get(1+3*4) + ai2 * b.get(2+3*4) + ai3 * b.get(3+3*4) );
+          final float ai0=a.get(aP+i+0*4),  ai1=a.get(aP+i+1*4),  ai2=a.get(aP+i+2*4),  ai3=a.get(aP+i+3*4);
+          d.put(dP+i+0*4 , ai0 * b.get(bP+0+0*4) + ai1 * b.get(bP+1+0*4) + ai2 * b.get(bP+2+0*4) + ai3 * b.get(bP+3+0*4) );
+          d.put(dP+i+1*4 , ai0 * b.get(bP+0+1*4) + ai1 * b.get(bP+1+1*4) + ai2 * b.get(bP+2+1*4) + ai3 * b.get(bP+3+1*4) );
+          d.put(dP+i+2*4 , ai0 * b.get(bP+0+2*4) + ai1 * b.get(bP+1+2*4) + ai2 * b.get(bP+2+2*4) + ai3 * b.get(bP+3+2*4) );
+          d.put(dP+i+3*4 , ai0 * b.get(bP+0+3*4) + ai1 * b.get(bP+1+3*4) + ai2 * b.get(bP+2+3*4) + ai3 * b.get(bP+3+3*4) );
        }
     }
-    public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer p) {
+    public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer d) {
+       final int aP = a.position(); 
+       final int dP = d.position();
        for (int i = 0; i < 4; i++) {
-          final float ai0=a.get(i+0*4),  ai1=a.get(i+1*4),  ai2=a.get(i+2*4),  ai3=a.get(i+3*4);
-          p.put(i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] );
-          p.put(i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] );
-          p.put(i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] );
-          p.put(i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] );
+          final float ai0=a.get(aP+i+0*4),  ai1=a.get(aP+i+1*4),  ai2=a.get(aP+i+2*4),  ai3=a.get(aP+i+3*4);
+          d.put(dP+i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] );
+          d.put(dP+i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] );
+          d.put(dP+i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] );
+          d.put(dP+i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] );
        }
     }
 
@@ -343,8 +410,8 @@ public class PMVMatrix implements GLMatrixFunc {
             params.put((float)matrixMode);
         } else {
             FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
-            params.put(matrix);
-            matrix.rewind();
+            params.put(matrix); // matrix -> params
+            matrix.reset();
         }
         params.position(pos);
     }
@@ -353,8 +420,8 @@ public class PMVMatrix implements GLMatrixFunc {
             params[params_offset]=(float)matrixMode;
         } else {
             FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
-            matrix.get(params, params_offset, 16);
-            matrix.rewind();
+            matrix.get(params, params_offset, 16); // matrix -> params
+            matrix.reset();
         }
     }
     public void glGetIntegerv(int pname, IntBuffer params) {
@@ -377,19 +444,16 @@ public class PMVMatrix implements GLMatrixFunc {
     public final void glLoadMatrixf(final float[] values, final int offset) {
         int len = values.length-offset;
         if(matrixMode==GL_MODELVIEW) {
-            matrixMv.clear();
             matrixMv.put(values, offset, len);
-            matrixMv.rewind();
+            matrixMv.reset();
             modified |= DIRTY_MODELVIEW ;
         } else if(matrixMode==GL_PROJECTION) {
-            matrixP.clear();
             matrixP.put(values, offset, len);
-            matrixP.rewind();
+            matrixP.reset();
             modified |= DIRTY_PROJECTION ;
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matrixTex.clear();
             matrixTex.put(values, offset, len);
-            matrixTex.rewind();
+            matrixTex.reset();
             modified |= DIRTY_TEXTURE ;
         } 
     }
@@ -397,19 +461,16 @@ public class PMVMatrix implements GLMatrixFunc {
     public final void glLoadMatrixf(java.nio.FloatBuffer m) {
         int spos = m.position();
         if(matrixMode==GL_MODELVIEW) {
-            matrixMv.clear();
             matrixMv.put(m);
-            matrixMv.rewind();
+            matrixMv.reset();
             modified |= DIRTY_MODELVIEW ;
         } else if(matrixMode==GL_PROJECTION) {
-            matrixP.clear();
             matrixP.put(m);
-            matrixP.rewind();
+            matrixP.reset();
             modified |= DIRTY_PROJECTION ;
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matrixTex.clear();
             matrixTex.put(m);
-            matrixTex.rewind();
+            matrixTex.reset();
             modified |= DIRTY_TEXTURE ;
         } 
         m.position(spos);
@@ -431,85 +492,60 @@ public class PMVMatrix implements GLMatrixFunc {
         float[] stackEntry = new float[1*16];
         if(matrixMode==GL_MODELVIEW) {
             matrixMv.get(stackEntry);
-            matrixMv.rewind();
+            matrixMv.reset();
             matrixMvStack.add(0, stackEntry);
         } else if(matrixMode==GL_PROJECTION) {
             matrixP.get(stackEntry);
-            matrixP.rewind();
+            matrixP.reset();
             matrixPStack.add(0, stackEntry);
         } else if(matrixMode==GL.GL_TEXTURE) {
             matrixTex.get(stackEntry);
-            matrixTex.rewind();
+            matrixTex.reset();
             matrixTStack.add(0, stackEntry);
         }
     }
 
     public final void glLoadIdentity() {
         if(matrixMode==GL_MODELVIEW) {
-            matrixMv.clear();
             matrixMv.put(matrixIdent);
-            matrixMv.rewind();
-            matrixIdent.rewind();
+            matrixMv.reset();
             modified |= DIRTY_MODELVIEW ;
         } else if(matrixMode==GL_PROJECTION) {
-            matrixP.clear();
             matrixP.put(matrixIdent);
-            matrixP.rewind();
-            matrixIdent.rewind();
+            matrixP.reset();
             modified |= DIRTY_PROJECTION ;
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matrixTex.clear();
             matrixTex.put(matrixIdent);
-            matrixTex.rewind();
-            matrixIdent.rewind();
+            matrixTex.reset();
             modified |= DIRTY_TEXTURE ;
         } 
+        matrixIdent.reset();
     }
 
     public final void glMultMatrixf(final FloatBuffer m) {
         if(matrixMode==GL_MODELVIEW) {
-            glMultMatrixf(matrixMv, m, matrixMult);
-            matrixMv.clear();
-            matrixMv.put(matrixMult);
-            matrixMv.rewind();
+            glMultMatrixf(matrixMv, m, matrixMv);
             modified |= DIRTY_MODELVIEW ;
         } else if(matrixMode==GL_PROJECTION) {
-            glMultMatrixf(matrixP, m, matrixMult);
-            matrixP.clear();
-            matrixP.put(matrixMult);
-            matrixP.rewind();
+            glMultMatrixf(matrixP, m, matrixP);
             modified |= DIRTY_PROJECTION ;
         } else if(matrixMode==GL.GL_TEXTURE) {
-            glMultMatrixf(matrixTex, m, matrixMult);
-            matrixTex.clear();
-            matrixTex.put(matrixMult);
-            matrixTex.rewind();
+            glMultMatrixf(matrixTex, m, matrixTex);
             modified |= DIRTY_TEXTURE ;
         } 
-        matrixMult.rewind();
     }
 
     public void glMultMatrixf(float[] m, int m_offset) {
         if(matrixMode==GL_MODELVIEW) {
-            glMultMatrixf(matrixMv, m, m_offset, matrixMult);
-            matrixMv.clear();
-            matrixMv.put(matrixMult);
-            matrixMv.rewind();
+            glMultMatrixf(matrixMv, m, m_offset, matrixMv);
             modified |= DIRTY_MODELVIEW ;
         } else if(matrixMode==GL_PROJECTION) {
-            glMultMatrixf(matrixP, m, m_offset, matrixMult);
-            matrixP.clear();
-            matrixP.put(matrixMult);
-            matrixP.rewind();
+            glMultMatrixf(matrixP, m, m_offset, matrixP);
             modified |= DIRTY_PROJECTION ;
         } else if(matrixMode==GL.GL_TEXTURE) {
-            glMultMatrixf(matrixTex, m, m_offset, matrixMult);
-            matrixTex.clear();
-            matrixTex.put(matrixMult);
-            matrixTex.rewind();
+            glMultMatrixf(matrixTex, m, m_offset, matrixTex);
             modified |= DIRTY_TEXTURE ;
         } 
-        matrixMult.rewind();
     }
 
     public final void glTranslatef(final float x, final float y, final float z) {
@@ -518,17 +554,17 @@ public class PMVMatrix implements GLMatrixFunc {
         //  0 1 0 y
         //  0 0 1 z
         //  0 0 0 1
-        matrixTrans.put(0+4*3, x);
-        matrixTrans.put(1+4*3, y);
-        matrixTrans.put(2+4*3, z);
-        glMultMatrixf(matrixTrans);
+        matrixTrans[0+4*3] = x;
+        matrixTrans[1+4*3] = y;
+        matrixTrans[2+4*3] = z;
+        glMultMatrixf(matrixTrans, 0);
     }
 
     public final void glRotatef(final float angdeg, float x, float y, float z) {
-        float angrad = angdeg   * (float) Math.PI / 180.0f;
-        float c = (float)Math.cos(angrad);
-        float ic= 1.0f - c; 
-        float s = (float)Math.sin(angrad);
+        final float angrad = angdeg   * (float) Math.PI / 180.0f;
+        final float c = (float)Math.cos(angrad);
+        final float ic= 1.0f - c; 
+        final float s = (float)Math.sin(angrad);
 
         vec3f[0]=x; vec3f[1]=y; vec3f[2]=z;
         ProjectFloat.normalize(vec3f);
@@ -539,25 +575,25 @@ public class PMVMatrix implements GLMatrixFunc {
         //      xy(1−c)-zs yy(1−c)+c  yz(1−c)+xs 0
         //      xz(1−c)+ys yz(1−c)-xs zz(1−c)+c  0
         //      0          0          0          1
-        float xy = x*y;
-        float xz = x*z;
-        float xs = x*s;
-        float ys = y*s;
-        float yz = y*z;
-        float zs = z*s;
-        matrixRot.put(0*4+0, x*x*ic+c);
-        matrixRot.put(0*4+1, xy*ic+zs);
-        matrixRot.put(0*4+2, xz*ic-ys);
+        final float xy = x*y;
+        final float xz = x*z;
+        final float xs = x*s;
+        final float ys = y*s;
+        final float yz = y*z;
+        final float zs = z*s;
+        matrixRot[0*4+0] = x*x*ic+c;
+        matrixRot[0*4+1] = xy*ic+zs;
+        matrixRot[0*4+2] = xz*ic-ys;
 
-        matrixRot.put(1*4+0, xy*ic-zs);
-        matrixRot.put(1*4+1, y*y*ic+c);
-        matrixRot.put(1*4+2, yz*ic+xs);
+        matrixRot[1*4+0] = xy*ic-zs;
+        matrixRot[1*4+1] = y*y*ic+c;
+        matrixRot[1*4+2] = yz*ic+xs;
 
-        matrixRot.put(2*4+0, xz*ic+ys);
-        matrixRot.put(2*4+1, yz*ic-xs);
-        matrixRot.put(2*4+2, z*z*ic+c);
+        matrixRot[2*4+0] = xz*ic+ys;
+        matrixRot[2*4+1] = yz*ic-xs;
+        matrixRot[2*4+2] = z*z*ic+c;
 
-        glMultMatrixf(matrixRot);
+        glMultMatrixf(matrixRot, 0);
     }
 
     public final void glScalef(final float x, final float y, final float z) {
@@ -566,11 +602,11 @@ public class PMVMatrix implements GLMatrixFunc {
         //  0 y 0 0
         //  0 0 z 0
         //  0 0 0 1
-        matrixScale.put(0+4*0, x);
-        matrixScale.put(1+4*1, y);
-        matrixScale.put(2+4*2, z);
+        matrixScale[0+4*0] = x;
+        matrixScale[1+4*1] = y;
+        matrixScale[2+4*2] = z;
 
-        glMultMatrixf(matrixScale);
+        glMultMatrixf(matrixScale, 0);
     }
 
     public final void glOrthof(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
@@ -579,21 +615,21 @@ public class PMVMatrix implements GLMatrixFunc {
         //  0     2/dy  0    ty
         //  0     0     2/dz tz
         //  0     0     0    1
-        float dx=right-left;
-        float dy=top-bottom;
-        float dz=zFar-zNear;
-        float tx=-1.0f*(right+left)/dx;
-        float ty=-1.0f*(top+bottom)/dy;
-        float tz=-1.0f*(zFar+zNear)/dz;
+        final float dx=right-left;
+        final float dy=top-bottom;
+        final float dz=zFar-zNear;
+        final float tx=-1.0f*(right+left)/dx;
+        final float ty=-1.0f*(top+bottom)/dy;
+        final float tz=-1.0f*(zFar+zNear)/dz;
 
-        matrixOrtho.put(0+4*0, 2.0f/dx);
-        matrixOrtho.put(1+4*1, 2.0f/dy);
-        matrixOrtho.put(2+4*2, -2.0f/dz);
-        matrixOrtho.put(0+4*3, tx);
-        matrixOrtho.put(1+4*3, ty);
-        matrixOrtho.put(2+4*3, tz);
+        matrixOrtho[0+4*0] =  2.0f/dx;
+        matrixOrtho[1+4*1] =  2.0f/dy;
+        matrixOrtho[2+4*2] = -2.0f/dz;
+        matrixOrtho[0+4*3] = tx;
+        matrixOrtho[1+4*3] = ty;
+        matrixOrtho[2+4*3] = tz;
 
-        glMultMatrixf(matrixOrtho);
+        glMultMatrixf(matrixOrtho, 0);
     }
 
     public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
@@ -608,52 +644,87 @@ public class PMVMatrix implements GLMatrixFunc {
         //  0            2*zNear/dy B  0
         //  0            0          C  D
         //  0            0         −1  0
-        float zNear2 = 2.0f*zNear;
-        float dx=right-left;
-        float dy=top-bottom;
-        float dz=zFar-zNear;
-        float A=(right+left)/dx;
-        float B=(top+bottom)/dy;
-        float C=-1.0f*(zFar+zNear)/dz;
-        float D=-2.0f*(zFar*zNear)/dz;
+        final float zNear2 = 2.0f*zNear;
+        final float dx=right-left;
+        final float dy=top-bottom;
+        final float dz=zFar-zNear;
+        final float A=(right+left)/dx;
+        final float B=(top+bottom)/dy;
+        final float C=-1.0f*(zFar+zNear)/dz;
+        final float D=-2.0f*(zFar*zNear)/dz;
 
-        matrixFrustum.put(0+4*0, zNear2/dx);
-        matrixFrustum.put(1+4*1, zNear2/dy);
-        matrixFrustum.put(2+4*2, C);
+        matrixFrustum[0+4*0] = zNear2/dx;
+        matrixFrustum[1+4*1] = zNear2/dy;
+        matrixFrustum[2+4*2] = C;
 
-        matrixFrustum.put(0+4*2, A);
-        matrixFrustum.put(1+4*2, B);
+        matrixFrustum[0+4*2] = A;
+        matrixFrustum[1+4*2] = B;
 
-        matrixFrustum.put(2+4*3, D);
-        matrixFrustum.put(3+4*2, -1.0f);
+        matrixFrustum[2+4*3] = D;
+        matrixFrustum[3+4*2] = -1.0f;
 
-        glMultMatrixf(matrixFrustum);
+        glMultMatrixf(matrixFrustum, 0);
     }
 
     //
     // private 
     //
+    private int nioBackupArraySupported = 0; // -1 not supported, 0 - TBD, 1 - supported
+    private final String msgCantComputeInverse = "Invalid source Mv matrix, can't compute inverse";
 
     private final void setMviMvit() {
-        if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) {
-            throw new GLException("Invalid source Mv matrix, can't compute inverse");
+        if( 0 != (usesMviMvit & 1) ) {
+            if(nioBackupArraySupported>=0) {
+                try {
+                    setMviMvitNIOBackupArray();
+                    nioBackupArraySupported = 1;
+                    return;
+                } catch(UnsupportedOperationException uoe) {
+                    nioBackupArraySupported = -1;
+                }
+            }
+            setMviMvitNIODirectAccess();
         }
-
-        // transpose matrix 
-        for (int i = 0; i < 4; i++) {
-            for (int j = 0; j < 4; j++) {
-                matrixMvit.put(j+i*4, matrixMvi.get(i+j*4));
+    }
+    private final void setMviMvitNIOBackupArray() {
+        final float[] _matrixMvi = matrixMvi.array();
+        final int _matrixMviOffset = matrixMvi.position();
+        if(!projectFloat.gluInvertMatrixf(matrixMv.array(), matrixMv.position(), _matrixMvi, _matrixMviOffset)) {
+            throw new GLException(msgCantComputeInverse);
+        }
+        if( 0 != (usesMviMvit & 2) ) {
+            // transpose matrix 
+            final float[] _matrixMvit = matrixMvit.array();
+            final int _matrixMvitOffset = matrixMvit.position();
+            for (int i = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++) {
+                    _matrixMvit[_matrixMvitOffset+j+i*4] = _matrixMvi[_matrixMviOffset+i+j*4];
+                }
             }
+        }        
+    }
+    
+    private final void setMviMvitNIODirectAccess() {
+        if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) {
+            throw new GLException(msgCantComputeInverse);
         }
+        if( 0 != (usesMviMvit & 2) ) {
+            // transpose matrix 
+            for (int i = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++) {
+                    matrixMvit.put(j+i*4, matrixMvi.get(i+j*4));
+                }
+            }
+        }        
     }
 
-    protected ByteBuffer matrixBuffer;
+    protected Buffer matrixBuffer;
     protected FloatBuffer matrixIdent, matrixPMvMvit, matrixPMvMvi, matrixPMv, matrixP, matrixTex, matrixMv, matrixMvi, matrixMvit;
-    protected FloatBuffer matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum;
-    protected float[] vec3f;
+    protected float[] matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum, vec3f;
     protected List<float[]> matrixTStack, matrixPStack, matrixMvStack;
     protected int matrixMode = GL_MODELVIEW;
     protected int modified = 0;
+    protected int usesMviMvit = 0; // 0 - none, 1 - Mvi, 2 - Mvit, 3 - MviMvit (ofc no Mvit w/o Mvi!)
     protected ProjectFloat projectFloat;
 
     public static final int DIRTY_MODELVIEW  = 1 << 0;
diff --git a/src/jogl/classes/jogamp/opengl/ProjectFloat.java b/src/jogl/classes/jogamp/opengl/ProjectFloat.java
index a6316b242..1c69fa370 100644
--- a/src/jogl/classes/jogamp/opengl/ProjectFloat.java
+++ b/src/jogl/classes/jogamp/opengl/ProjectFloat.java
@@ -235,9 +235,18 @@ public class ProjectFloat {
   /**
    * Make matrix an identity matrix
    */
-  public static void gluMakeIdentityf(float[] m) {
+  public static void gluMakeIdentityf(float[] m, int offset) {
     for (int i = 0; i < 16; i++) {
-      m[i] = IDENTITY_MATRIX[i];
+      m[i+offset] = IDENTITY_MATRIX[i];
+    }
+  }
+
+  /**
+   * Make matrix an zero matrix
+   */
+  public static void gluMakeZero(float[] m, int offset) {
+    for (int i = 0; i < 16; i++) {
+      m[i+offset] = 0;
     }
   }
 
@@ -280,21 +289,22 @@ public class ProjectFloat {
 
   /**
    * @param src
+   * @param srcOffset
    * @param inverse
-   * 
+   * @param inverseOffset
    * @return
    */
-  public boolean gluInvertMatrixf(float[] src, float[] inverse) {
+  public boolean gluInvertMatrixf(float[] src, int srcOffset, float[] inverse, int inverseOffset) {
     int i, j, k, swap;
     float t;
     float[][] temp = tempInvertMatrix;
 
     for (i = 0; i < 4; i++) {
       for (j = 0; j < 4; j++) {
-        temp[i][j] = src[i*4+j];
+        temp[i][j] = src[i*4+j+srcOffset];
       }
     }
-    gluMakeIdentityf(inverse);
+    gluMakeIdentityf(inverse, inverseOffset);
 
     for (i = 0; i < 4; i++) {
       //
@@ -316,9 +326,9 @@ public class ProjectFloat {
           temp[i][k] = temp[swap][k];
           temp[swap][k] = t;
 
-          t = inverse[i*4+k];
-          inverse[i*4+k] = inverse[swap*4+k];
-          inverse[swap*4+k] = t;
+          t = inverse[i*4+k+inverseOffset];
+          inverse[i*4+k+inverseOffset] = inverse[swap*4+k+inverseOffset];
+          inverse[swap*4+k+inverseOffset] = t;
         }
       }
 
@@ -333,14 +343,14 @@ public class ProjectFloat {
       t = temp[i][i];
       for (k = 0; k < 4; k++) {
         temp[i][k] /= t;
-        inverse[i*4+k] /= t;
+        inverse[i*4+k+inverseOffset] /= t;
       }
       for (j = 0; j < 4; j++) {
         if (j != i) {
           t = temp[j][i];
           for (k = 0; k < 4; k++) {
             temp[j][k] -= temp[i][k] * t;
-            inverse[j*4+k] -= inverse[i*4+k]*t;
+            inverse[j*4+k+inverseOffset] -= inverse[i*4+k+inverseOffset]*t;
           }
         }
       }
@@ -781,7 +791,7 @@ public class ProjectFloat {
 
     gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
 
-    if (!gluInvertMatrixf(matrix, matrix))
+    if (!gluInvertMatrixf(matrix, 0, matrix, 0))
       return false;
 
     in[0] = winx;
@@ -907,7 +917,7 @@ public class ProjectFloat {
 
     gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
 
-    if (!gluInvertMatrixf(matrix, matrix))
+    if (!gluInvertMatrixf(matrix, 0, matrix, 0))
       return false;
 
     in[0] = winx;
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java
index 9bff38fce..050d9eb6e 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/GearsES2.java
@@ -56,6 +56,7 @@ public class GearsES2 implements GLEventListener {
     private GearsObjectES2 gear1=null, gear2=null, gear3=null;
     private float angle = 0.0f;
     private int swapInterval = 0;
+    private boolean pmvUseBackingArray = true; // the default for PMVMatrix now, since it's faster
     // private MouseListener gearsMouse = new TraceMouseAdapter(new GearsMouseAdapter());
     private MouseListener gearsMouse = new GearsMouseAdapter();    
     private KeyListener gearsKeys = new GearsKeyAdapter();
@@ -70,6 +71,10 @@ public class GearsES2 implements GLEventListener {
         this.swapInterval = 1;
     }
 
+    public void setPMVUseBackingArray(boolean pmvUseBackingArray) {
+        this.pmvUseBackingArray = pmvUseBackingArray;
+    }
+    
     public void setGears(GearsObjectES2 g1, GearsObjectES2 g2, GearsObjectES2 g3) {
         gear1 = g1;
         gear2 = g2;
@@ -119,7 +124,7 @@ public class GearsES2 implements GLEventListener {
         // Use debug pipeline
         // drawable.setGL(new DebugGL(drawable.getGL()));
 
-        pmvMatrix = new PMVMatrix();
+        pmvMatrix = new PMVMatrix(pmvUseBackingArray);
         st.attachObject("pmvMatrix", pmvMatrix);
         pmvMatrixUniform = new GLUniformData("pmvMatrix", 4, 4, pmvMatrix.glGetPMvMvitMatrixf()); // P, Mv, Mvi and Mvit
         st.ownUniform(pmvMatrixUniform);
@@ -189,10 +194,22 @@ public class GearsES2 implements GLEventListener {
         st.uniform(gl, pmvMatrixUniform);
         st.useProgram(gl, false);
         
+        try {
+            android.os.Debug.startMethodTracing("GearsES2.trace");
+            android.os.Debug.startAllocCounting();
+            useAndroidDebug = true;
+        } catch (NoClassDefFoundError e) {}
+        
         System.err.println(Thread.currentThread()+" GearsES2.reshape FIN");
     }
+    private boolean useAndroidDebug = false;
 
     public void dispose(GLAutoDrawable drawable) {
+        if(useAndroidDebug) {
+            android.os.Debug.stopAllocCounting();
+            android.os.Debug.stopMethodTracing();
+        }
+        
         System.err.println(Thread.currentThread()+" GearsES2.dispose ... ");
         if (drawable instanceof Window) {
             Window window = (Window) drawable;
@@ -244,7 +261,7 @@ public class GearsES2 implements GLEventListener {
         gear2.draw(gl,  3.1f, -2.0f, -2f * angle -  9.0f, GearsObject.green);
         gear3.draw(gl, -3.1f,  4.2f, -2f * angle - 25.0f, GearsObject.blue);    
         pmvMatrix.glPopMatrix();
-        st.useProgram(gl, false);
+        st.useProgram(gl, false);        
     }
 
     class GearsKeyAdapter extends KeyAdapter {      
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
index df86b83d2..64eb518fb 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
@@ -28,6 +28,10 @@
  
 package com.jogamp.opengl.test.junit.jogl.demos.es2.newt;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
 import com.jogamp.newt.event.KeyAdapter;
 import com.jogamp.newt.event.KeyEvent;
 import com.jogamp.newt.opengl.GLWindow;
@@ -38,7 +42,10 @@ import com.jogamp.opengl.util.Animator;
 
 import com.jogamp.opengl.test.junit.jogl.demos.es2.GearsES2;
 
+import javax.media.opengl.GLAnimatorControl;
+import javax.media.opengl.GLAutoDrawable;
 import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLEventListener;
 import javax.media.opengl.GLProfile;
 
 import org.junit.Assert;
@@ -78,7 +85,29 @@ public class TestGearsES2NEWT extends UITestCase {
         glWindow.setUndecorated(undecorated);
         glWindow.setAlwaysOnTop(alwaysOnTop);
         glWindow.setFullscreen(fullscreen);
-        glWindow.addGLEventListener(new GearsES2());
+        GearsES2 demo = new GearsES2(vsync ? 1 : 0);
+        demo.setPMVUseBackingArray(pmvUseBackingArray);
+        glWindow.addGLEventListener(demo);
+        if(waitForKey) {
+            glWindow.addGLEventListener(new GLEventListener() {
+                public void init(GLAutoDrawable drawable) { }
+                public void dispose(GLAutoDrawable drawable) { }
+                public void display(GLAutoDrawable drawable) {
+                    GLAnimatorControl  actrl = drawable.getAnimator();
+                    if(waitForKey && actrl.getTotalFPSFrames() == 60*3) {
+                        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
+                        System.err.println("Press enter to continue");
+                        try {
+                            System.err.println(stdin.readLine());
+                        } catch (IOException e) { }
+                        actrl.resetFPSCounter();
+                        waitForKey = false;
+                    }
+                }
+                public void reshape(GLAutoDrawable drawable, int x, int y,
+                        int width, int height) { }
+            });
+        }
 
         Animator animator = new Animator(glWindow);
         QuitAdapter quitAdapter = new QuitAdapter();
@@ -128,7 +157,7 @@ public class TestGearsES2NEWT extends UITestCase {
         System.err.println("size/pos: "+f_glWindow.getX()+"/"+f_glWindow.getY()+" "+f_glWindow.getWidth()+"x"+f_glWindow.getHeight()+", "+f_glWindow.getInsets());
         System.err.println("chosen: "+glWindow.getChosenCapabilities());
         
-        animator.setUpdateFPSFrames(1, null);
+        animator.setUpdateFPSFrames(60, System.err);
         animator.start();
 
         while(!quitAdapter.shouldQuit() && animator.isAnimating() && animator.getTotalFPSDuration()<duration) {
@@ -151,8 +180,12 @@ public class TestGearsES2NEWT extends UITestCase {
     static boolean undecorated = false;
     static boolean alwaysOnTop = false;
     static boolean fullscreen = false;
+    static boolean pmvUseBackingArray = true;
+    static boolean vsync = false;
+    static boolean waitForKey = false;
 
-    public static void main(String args[]) {
+    public static void main(String args[]) throws IOException {
+        
         for(int i=0; i<args.length; i++) {
             if(args[i].equals("-time")) {
                 i++;
@@ -167,8 +200,28 @@ public class TestGearsES2NEWT extends UITestCase {
                 alwaysOnTop = true;
             } else if(args[i].equals("-fullscreen")) {
                 fullscreen = true;
+            } else if(args[i].equals("-pmvDirect")) {
+                pmvUseBackingArray = false;
+            } else if(args[i].equals("-vsync")) {
+                vsync = true;
+            } else if(args[i].equals("-wait")) {
+                waitForKey = true;
             }
         }
+        System.err.println("translucent "+(!opaque));
+        System.err.println("undecorated "+undecorated);
+        System.err.println("atop "+alwaysOnTop);
+        System.err.println("fullscreen "+fullscreen);
+        System.err.println("pmvDirect "+(!pmvUseBackingArray));
+        System.err.println("vsync "+vsync);
+
+        if(waitForKey) {
+            BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
+            System.err.println("Press enter to continue");
+            try {
+                System.err.println(stdin.readLine());
+            } catch (IOException e) { }
+        }
         org.junit.runner.JUnitCore.main(TestGearsES2NEWT.class.getName());
     }
 }