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[]

1 files changed, 248 insertions, 177 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;