Misc Rename/Reloc; GLArrayData*/PMVMatrix enhancments; Test fixes/adds (GearsES1/ES2)

rename/reloc:
 - javax.media.nativewindow.util:
      DimensionReadOnly -> DimensionImmutable
      PointReadOnly -> PointImmutable
      RectangleReadOnly -> RectangleImmutable

   unified 'immutable' name as used within jogamp already

 - remove array handler from public API
   com.jogamp.opengl.util.GL*ArrayHandler -> jogamp.opengl.util.GL*ArrayHandler

 - GLArrayData: Clarify method names
     getComponentNumber() -> getComponentCount()
     getComponentSize() -> getComponentSizeInBytes()
     getElementNumber() -> getElementCount()
     getByteSize() -> getSizeInBytes()

- FixedFuncPipeline: Moved def. array names to GLPointerFuncUtil

enhancement:
  - GLArrayDataServer: Add support for interleaved arrays/VBO
  - GLArrayData*.createFixed(..) remove 'name' argument (non sense for fixed function)
  - PMVMatrix:
    - one nio buffer
    - removed 'Pmv' multiplied matrix
    - removed 2x2 cut down 'Mvi' normal matrix (use 4x4 Mvi)
    -
tests:
 - RedSquare -> RedSquareES1/RedSquareES2
 - Gears ES1 fixed + ES2 added. Both work properly and share common Gears VBO construction
 - Added TestMapBuffer01NEWT, testing glMapBuffer

12 files changed, 659 insertions, 39 deletions

diff --git a/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java
new file mode 100644
index 000000000..718b63822
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java
@@ -0,0 +1,73 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+
+import java.nio.*;
+
+/**
+ * Used for pure VBO data arrays, i.e. where the buffer data 
+ * does not represents a specific array name. 
+ */
+public class GLDataArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLDataArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+    if(!ad.isVBO()) {
+        // makes no sense otherwise
+        throw new GLException("GLDataArrayHandler can only handle VBOs.");
+    }
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      throw new UnsupportedOperationException();
+  }
+  
+  public final void enableBuffer(GL gl, boolean enable) {
+    if(enable) {
+        Buffer buffer = ad.getBuffer();
+
+        // always bind and refresh the VBO mgr, 
+        // in case more than one gl*Pointer objects are in use
+        gl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+        if(!ad.isVBOWritten()) {
+            if(null!=buffer) {
+                gl.glBufferData(ad.getVBOTarget(), buffer.limit() * ad.getComponentSizeInBytes(), buffer, ad.getVBOUsage());
+            }
+            ad.setVBOWritten(true);
+        }
+    } else {
+        gl.glBindBuffer(ad.getVBOTarget(), 0);
+    }
+  }
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java
new file mode 100644
index 000000000..e365f0f4b
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java
@@ -0,0 +1,99 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+
+import com.jogamp.opengl.util.GLArrayDataEditable;
+import com.jogamp.opengl.util.GLArrayHandler;
+
+import java.nio.*;
+
+/**
+ * Used for 1:1 fixed function arrays, i.e. where the buffer data 
+ * represents this array only. 
+ */
+public class GLFixedArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLFixedArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      throw new UnsupportedOperationException();
+  }
+  
+  private final void passArrayPointer(GLPointerFunc gl) {
+    switch(ad.getIndex()) {
+        case GLPointerFunc.GL_VERTEX_ARRAY:
+            gl.glVertexPointer(ad);
+            break;
+        case GLPointerFunc.GL_NORMAL_ARRAY:
+            gl.glNormalPointer(ad);
+            break;
+        case GLPointerFunc.GL_COLOR_ARRAY:
+            gl.glColorPointer(ad);
+            break;
+        case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+            gl.glTexCoordPointer(ad);
+            break;
+        default:
+            throw new GLException("invalid glArrayIndex: "+ad.getIndex()+":\n\t"+ad); 
+    }
+  }
+
+  public final void enableBuffer(GL gl, boolean enable) {
+    GLPointerFunc glp = gl.getGL2ES1();
+    if(enable) {
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr, 
+            // in case more than one gl*Pointer objects are in use
+            gl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+            if(!ad.isVBOWritten()) {
+                if(null!=buffer) {
+                    gl.glBufferData(ad.getVBOTarget(), buffer.limit() * ad.getComponentSizeInBytes(), buffer, ad.getVBOUsage());
+                }
+                ad.setVBOWritten(true);
+            }
+        }
+        passArrayPointer(glp);
+        glp.glEnableClientState(ad.getIndex());        
+    } else {
+        glp.glDisableClientState(ad.getIndex());
+        if(ad.isVBO()) {
+            gl.glBindBuffer(ad.getVBOTarget(), 0);
+        }
+    }
+  }
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java
new file mode 100644
index 000000000..e1cf5d572
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java
@@ -0,0 +1,82 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GLArrayData;
+import javax.media.opengl.GLException;
+import javax.media.opengl.fixedfunc.GLPointerFunc;
+
+import com.jogamp.opengl.util.GLArrayHandler;
+
+/**
+ * Used for interleaved fixed function arrays, i.e. where the buffer data itself is handled 
+ * separately and interleaves many arrays.
+ */
+public class GLFixedArrayHandlerFlat implements GLArrayHandler {
+  private GLArrayData ad;
+
+  public GLFixedArrayHandlerFlat(GLArrayData ad) {
+    this.ad = ad;
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      throw new UnsupportedOperationException();
+  }
+  
+  private final void passArrayPointer(GLPointerFunc gl) {
+    switch(ad.getIndex()) {
+        case GLPointerFunc.GL_VERTEX_ARRAY:
+            gl.glVertexPointer(ad);
+            break;
+        case GLPointerFunc.GL_NORMAL_ARRAY:
+            gl.glNormalPointer(ad);
+            break;
+        case GLPointerFunc.GL_COLOR_ARRAY:
+            gl.glColorPointer(ad);
+            break;
+        case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+            gl.glTexCoordPointer(ad);
+            break;
+        default:
+            throw new GLException("invalid glArrayIndex: "+ad.getIndex()+":\n\t"+ad); 
+    }
+  }
+
+  public final void enableBuffer(GL gl, boolean enable) {
+    GLPointerFunc glp = gl.getGL2ES1();
+    if(enable) {
+        passArrayPointer(glp);
+        glp.glEnableClientState(ad.getIndex());        
+    } else {
+        glp.glDisableClientState(ad.getIndex());
+    }
+  }
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerInterleaved.java b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerInterleaved.java
new file mode 100644
index 000000000..838032646
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerInterleaved.java
@@ -0,0 +1,87 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+
+import com.jogamp.opengl.util.GLArrayDataEditable;
+import com.jogamp.opengl.util.GLArrayHandler;
+
+import java.nio.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Interleaved fixed function arrays, i.e. where this buffer data 
+ * represents many arrays. 
+ */
+public class GLFixedArrayHandlerInterleaved implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+  private List<GLArrayHandler> subArrays = new ArrayList<GLArrayHandler>();
+
+  public GLFixedArrayHandlerInterleaved(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+  
+  public final void addSubHandler(GLArrayHandler handler) {
+      subArrays.add(handler);
+  }
+
+  private final void enableSubBuffer(GL gl, boolean enable) {
+      for(int i=0; i<subArrays.size(); i++) {
+          subArrays.get(i).enableBuffer(gl, enable);
+      }      
+  }
+  
+  public final void enableBuffer(GL gl, boolean enable) {
+    if(enable) {
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr, 
+            // in case more than one gl*Pointer objects are in use
+            gl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+            if(!ad.isVBOWritten()) {
+                if(null!=buffer) {
+                    gl.glBufferData(ad.getVBOTarget(), buffer.limit() * ad.getComponentSizeInBytes(), buffer, ad.getVBOUsage());
+                }
+                ad.setVBOWritten(true);
+            }
+        }
+        enableSubBuffer(gl, true);
+    } else {
+        enableSubBuffer(gl, false);
+        if(ad.isVBO()) {
+            gl.glBindBuffer(ad.getVBOTarget(), 0);
+        }
+    }
+  }
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java
new file mode 100644
index 000000000..b4b7b5ace
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util.glsl;
+
+import java.nio.Buffer;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLException;
+import com.jogamp.opengl.util.GLArrayDataEditable;
+import com.jogamp.opengl.util.GLArrayHandler;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+/**
+ * Used for 1:1 GLSL arrays, i.e. where the buffer data 
+ * represents this array only. 
+ */
+public class GLSLArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+  private ShaderState st;
+
+  public GLSLArrayHandler(ShaderState st, GLArrayDataEditable ad) {
+    this.st = st;
+    this.ad = ad;
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      throw new UnsupportedOperationException();
+  }
+  
+  public final void enableBuffer(GL gl, boolean enable) {
+    GL2ES2 glsl = gl.getGL2ES2();
+
+    if(enable) {
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // bind and refresh the VBO / vertex-attr only if necessary
+            if(!ad.isVBOWritten()) {
+                glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+                if(null!=buffer) {
+                    glsl.glBufferData(ad.getVBOTarget(), ad.getSizeInBytes(), buffer, ad.getVBOUsage());
+                }
+                ad.setVBOWritten(true);
+                st.vertexAttribPointer(glsl, ad);
+            } else if(ad.getLocation() >= 0) {
+                // didn't experience a performance hit on this query ..
+                final int[] qi = new int[1];
+                glsl.glGetVertexAttribiv(ad.getLocation(), GL2ES2.GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, qi, 0);
+                if(ad.getVBOName() != qi[0]) {
+                    glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+                    st.vertexAttribPointer(glsl, ad);
+                }
+            }
+        } else if(null!=buffer) {
+            st.vertexAttribPointer(glsl, ad);
+        }
+        st.enableVertexAttribArray(glsl, ad);
+    } else {
+        st.disableVertexAttribArray(glsl, ad);
+        if(ad.isVBO()) {
+            glsl.glBindBuffer(ad.getVBOTarget(), 0);
+        }
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java
new file mode 100644
index 000000000..38379877f
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util.glsl;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLArrayData;
+import com.jogamp.opengl.util.GLArrayHandler;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+/**
+ * Used for interleaved GLSL arrays, i.e. where the buffer data itself is handled 
+ * separately and interleaves many arrays.
+ */
+public class GLSLArrayHandlerFlat implements GLArrayHandler {
+  private ShaderState st;
+  private GLArrayData ad;
+
+  public GLSLArrayHandlerFlat(ShaderState st, GLArrayData ad) {
+    this.st = st;
+    this.ad = ad;
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      throw new UnsupportedOperationException();
+  }
+  
+  public final void enableBuffer(GL gl, boolean enable) {
+    GL2ES2 glsl = gl.getGL2ES2();
+
+    if(enable) {
+        st.vertexAttribPointer(glsl, ad);
+        st.enableVertexAttribArray(glsl, ad);
+    } else {
+        st.disableVertexAttribArray(glsl, ad);
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java
new file mode 100644
index 000000000..ba5814a09
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package jogamp.opengl.util.glsl;
+
+import java.nio.Buffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLException;
+
+import jogamp.opengl.util.GLFixedArrayHandlerFlat;
+
+import com.jogamp.opengl.util.GLArrayDataEditable;
+import com.jogamp.opengl.util.GLArrayHandler;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+/**
+ * Interleaved GLSL arrays, i.e. where this buffer data 
+ * represents many arrays. 
+ */
+public class GLSLArrayHandlerInterleaved implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+  private ShaderState st;
+  private List<GLArrayHandler> subArrays = new ArrayList<GLArrayHandler>();
+
+  public GLSLArrayHandlerInterleaved(ShaderState st, GLArrayDataEditable ad) {
+    this.st = st;
+    this.ad = ad;
+  }
+
+  public final void addSubHandler(GLArrayHandler handler) {
+      subArrays.add(handler);
+  }
+
+  private final void enableSubBuffer(GL gl, boolean enable) {
+      for(int i=0; i<subArrays.size(); i++) {
+          subArrays.get(i).enableBuffer(gl, enable);
+      }      
+  }
+  
+  public final void enableBuffer(GL gl, boolean enable) {
+    GL2ES2 glsl = gl.getGL2ES2();
+
+    if(enable) {
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr, 
+            // in case more than one attributes are in use
+            glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName());
+            if(!ad.isVBOWritten()) {
+                if(null!=buffer) {
+                    glsl.glBufferData(ad.getVBOTarget(), ad.getSizeInBytes(), buffer, ad.getVBOUsage());
+                }
+                ad.setVBOWritten(true);
+            }
+        }
+        enableSubBuffer(gl, true);
+    } else {
+        enableSubBuffer(gl, false);
+        if(ad.isVBO()) {
+            glsl.glBindBuffer(ad.getVBOTarget(), 0);
+        }
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
index 984439031..2d18ba248 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
@@ -1,5 +1,30 @@
 /*
  * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
  */
 
 package jogamp.opengl.util.glsl.fixedfunc;
@@ -254,7 +279,7 @@ public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFun
     }
 
     public void glNormalPointer(GLArrayData array) {
-      if(array.getComponentNumber()!=3) {
+      if(array.getComponentCount()!=3) {
         throw new GLException("Only 3 components per normal allowed");
       }
       if(array.isVBO()) {
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
index 2218c2d73..7bc0c5468 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
@@ -1,3 +1,31 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 package jogamp.opengl.util.glsl.fixedfunc;
 
@@ -12,26 +40,6 @@ public class FixedFuncPipeline {
     public static final int MAX_TEXTURE_UNITS = 8;
     public static final int MAX_LIGHTS        = 8;
 
-    // We can't have any dependencies on the FixedFuncUtil class for build bootstrapping reasons
-    public static final String mgl_Vertex = "mgl_Vertex";
-    public static final String mgl_Normal = "mgl_Normal";
-    public static final String mgl_Color = "mgl_Color";
-    public static final String mgl_MultiTexCoord = "mgl_MultiTexCoord" ;
-
-    public static String getPredefinedArrayIndexName(int glArrayIndex) {
-        switch(glArrayIndex) {
-            case GLPointerFunc.GL_VERTEX_ARRAY:
-                return mgl_Vertex;
-            case GLPointerFunc.GL_NORMAL_ARRAY:
-                return mgl_Normal;
-            case GLPointerFunc.GL_COLOR_ARRAY:
-                return mgl_Color;
-            case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
-                return mgl_MultiTexCoord;
-        }
-        return null;
-    }
-
     public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix) {
         init(gl, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, shaderBinRootDef, 
              vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef);
@@ -62,7 +70,7 @@ public class FixedFuncPipeline {
     }
 
     public String getArrayIndexName(int glArrayIndex) {
-      String name = getPredefinedArrayIndexName(glArrayIndex); 
+      String name = GLPointerFuncUtil.getPredefinedArrayIndexName(glArrayIndex); 
       switch(glArrayIndex) {
           case GLPointerFunc.GL_VERTEX_ARRAY:
           case GLPointerFunc.GL_NORMAL_ARRAY:
@@ -320,15 +328,10 @@ public class FixedFuncPipeline {
             } else {
                 throw new GLException("Failed to update: mgl_PMVMatrix");
             }
-            ud = shaderState.getUniform(mgl_NormalMatrix);
-            if(null!=ud) {
-                // same data object ..
-                shaderState.uniform(gl, ud);
-            }
         }
         ud = shaderState.getUniform(mgl_ColorEnabled);
         if(null!=ud) {
-            int ca = (shaderState.isVertexAttribArrayEnabled(mgl_Color)==true)?1:0;
+            int ca = (shaderState.isVertexAttribArrayEnabled(GLPointerFuncUtil.mgl_Color)==true)?1:0;
             if(ca!=ud.intValue()) {
                 ud.setData(ca);
                 shaderState.uniform(gl, ud);
@@ -450,13 +453,10 @@ public class FixedFuncPipeline {
         shaderState.useProgram(gl, true);
 
         // mandatory ..
-        if(!shaderState.uniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.glGetPMvMviMatrixf()))) {
+        if(!shaderState.uniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.glGetPMvMvitMatrixf()))) {
             throw new GLException("Error setting PMVMatrix in shader: "+this);
         }
 
-        // optional parameter ..
-        shaderState.uniform(gl, new GLUniformData(mgl_NormalMatrix, 3, 3, pmvMatrix.glGetNormalMatrixf()));
-
         shaderState.uniform(gl, new GLUniformData(mgl_ColorEnabled,  0));
         shaderState.uniform(gl, new GLUniformData(mgl_ColorStatic, 4, zero4f));
         shaderState.uniform(gl, new GLUniformData(mgl_TexCoordEnabled,  1, textureCoordsEnabled));
@@ -508,8 +508,7 @@ public class FixedFuncPipeline {
     protected ShaderProgram shaderProgramColorTextureLight;
 
     // uniforms ..
-    protected static final String mgl_PMVMatrix        = "mgl_PMVMatrix";       // m4fv[3]
-    protected static final String mgl_NormalMatrix     = "mgl_NormalMatrix";    // m4fv
+    protected static final String mgl_PMVMatrix        = "mgl_PMVMatrix";       // m4fv[4] - P, Mv, Mvi and Mvit
     protected static final String mgl_ColorEnabled     = "mgl_ColorEnabled";    //  1i
     protected static final String mgl_ColorStatic      = "mgl_ColorStatic";     //  4fv
 
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorLight.vp b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorLight.vp
index ce203cfb9..7ce1eedcf 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorLight.vp
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorLight.vp
@@ -19,7 +19,7 @@ void main(void)
 
   position  = mgl_PMVMatrix[1] * mgl_Vertex; // vertex eye position 
 
-  normal = normalize(mgl_NormalMatrix * mgl_Normal); 
+  normal = normalize(mgl_PMVMatrix[3] * mgl_Normal).xyz; 
   // cameraPosition:      (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz                   
   cameraDir  = normalize( (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz - mgl_Vertex.xyz ); 
 
@@ -50,7 +50,7 @@ void main(void)
       }
     }
   }
-  ambient  += mgl_FrontMaterial.ambient;
+  ambient  *= mgl_FrontMaterial.ambient;
   diffuse  *= mgl_FrontMaterial.diffuse;
   specular *= mgl_FrontMaterial.specular;
 
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
index b09bdb05a..09a11ec95 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
@@ -5,7 +5,7 @@
 #include es_precision.glsl
 
 attribute HIGHP vec4    mgl_Vertex;
-attribute HIGHP vec3    mgl_Normal;
+attribute HIGHP vec4    mgl_Normal;
 attribute HIGHP vec4    mgl_Color;
 attribute HIGHP vec4    mgl_MultiTexCoord0;
 attribute HIGHP vec4    mgl_MultiTexCoord1;
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
index d8b3c7f95..4c4000dfa 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
@@ -6,8 +6,7 @@
 
 #include mgl_const.glsl
 
-uniform   HIGHP mat4    mgl_PMVMatrix[3]; // P, Mv, and Mvi
-uniform   HIGHP mat3    mgl_NormalMatrix; // transpose(inverse(ModelView)).3x3
+uniform HIGHP   mat4    mgl_PMVMatrix[4]; // P, Mv, Mvi and Mvit (transpose(inverse(ModelView)) == normalMatrix)
 uniform LOWP    int     mgl_ColorEnabled;
 uniform HIGHP   vec4    mgl_ColorStatic;
 uniform LOWP    int     mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];