Bug 942: GLBufferObjectTracker Enhancement [2/2]: Add mapped buffer capabilities to GLArrayDataServer and add unit tests

GLArrayDataServer:
  - Add create*Mapped(..) variants for GPU mapped buffer usage
    w/o client buffers.

  - Fix API documentation (arguments)

  - Fix 'addGLSLSubArray(..)'
    - properly compute and pass 'subStrideB' in bytes to GLArrayDataWrapper ctor.

  - Add 'mapStorage(..)' and 'unmapStorage(..)'
    allowing to map the GPU buffer.

GLArrayDataWrapper:
  - Fix getElementCount(): Consider stride in bytes and consider 'mappedElementCount'
  - getSizeInBytes(): Consider 'mappedElementCount'

Tests:
  - Use new GLBase methods, e.g. getBoundBuffer(..) instead of glGetBoundBuffer(..)

  - TestMapBufferRead01NEWT: Validate GLBufferStorage (i.e. GLBufferObjectTracker)

  - Add RedSquareMappedES2 using GPU mapped buffer
    - Test w/ TestRedSquareES2NEWT, cmd-line 'mappedBuffers'

  - GearsES1 and GearsES2: Add GPU buffer mapping mode for all test cases
    - Add buffer validation mode, i.e. test whether GLBufferObjectTracker
      works properly.

    - Test w/ TestGearsES2NEWT, cmd-line 'mappedBuffers'

  - TestSharedContextVBOES2NEWT0, TestSharedContextVBOES2NEWT3:
    - Add GPU mapped buffers tests to validate GLBufferObjectTracker
      code path with shared GLContext across multiple threads.

3 files changed, 399 insertions, 134 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java
index f84342e88..a58eb82cd 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java
@@ -74,7 +74,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   {
       GLArrayDataClient adc = new GLArrayDataClient();
       GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc);
-      adc.init(null, index, comps, dataType, normalized, 0, null, initialElementCount, false, glArrayHandler, 0, 0, 0, 0, false);
+      adc.init(null, index, comps, dataType, normalized, 0, null, initialElementCount, 0 /* mappedElementCount */, false, glArrayHandler, 0, 0, 0, 0, false);
       return adc;
   }
 
@@ -105,7 +105,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   {
       GLArrayDataClient adc = new GLArrayDataClient();
       GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc);
-      adc.init(null, index, comps, dataType, normalized, stride, buffer, comps*comps, false, glArrayHandler, 0, 0, 0, 0, false);
+      adc.init(null, index, comps, dataType, normalized, stride, buffer, comps*comps, 0 /* mappedElementCount */, false, glArrayHandler, 0, 0, 0, 0, false);
       return adc;
   }
 
@@ -124,7 +124,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   {
       GLArrayDataClient adc = new GLArrayDataClient();
       GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc);
-      adc.init(name, -1, comps, dataType, normalized, 0, null, initialElementCount, true, glArrayHandler, 0, 0, 0, 0, true);
+      adc.init(name, -1, comps, dataType, normalized, 0, null, initialElementCount, 0 /* mappedElementCount */, true, glArrayHandler, 0, 0, 0, 0, true);
       return adc;
   }
 
@@ -144,7 +144,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   {
       GLArrayDataClient adc = new GLArrayDataClient();
       GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc);
-      adc.init(name, -1, comps, dataType, normalized, stride, buffer, comps*comps, true, glArrayHandler, 0, 0, 0, 0, true);
+      adc.init(name, -1, comps, dataType, normalized, stride, buffer, comps*comps, 0 /* mappedElementCount */, true, glArrayHandler, 0, 0, 0, 0, true);
       return adc;
   }
 
@@ -177,7 +177,9 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   //
 
   @Override
-  public final void setVBOWritten(boolean written) { bufferWritten=written; }
+  public final void setVBOWritten(boolean written) {
+      bufferWritten = ( 0 == mappedElementCount ) ? written : true;
+  }
 
   @Override
   public void destroy(GL gl) {
@@ -231,25 +233,25 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
 
   @Override
   public void reset() {
-    if(buffer!=null) {
+    if( buffer != null ) {
         buffer.clear();
     }
-    this.sealed=false;
-    this.bufferEnabled=false;
-    this.bufferWritten=false;
+    sealed = false;
+    bufferEnabled = false;
+    bufferWritten = ( 0 == mappedElementCount ) ? false : true;
   }
 
   @Override
   public void seal(boolean seal)
   {
-    if(sealed==seal) return;
+    if( sealed == seal ) return;
     sealed = seal;
-    bufferWritten=false;
-    if(seal) {
-        if (null!=buffer) {
+    bufferWritten = ( 0 == mappedElementCount ) ? false : true;
+    if( seal ) {
+        if ( null != buffer ) {
             buffer.flip();
         }
-    } else if (null!=buffer) {
+    } else if ( null != buffer ) {
         buffer.position(buffer.limit());
         buffer.limit(buffer.capacity());
     }
@@ -333,8 +335,9 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
                        ", dataType 0x"+Integer.toHexString(componentType)+
                        ", bufferClazz "+componentClazz+
                        ", elements "+getElementCount()+
-                       ", components "+components+
+                       ", components "+componentsPerElement+
                        ", stride "+strideB+"b "+strideL+"c"+
+                       ", mappedElementCount "+mappedElementCount+
                        ", initialElementCount "+initialElementCount+
                        ", sealed "+sealed+
                        ", bufferEnabled "+bufferEnabled+
@@ -346,9 +349,14 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
 
   // non public matters
 
-  protected final boolean growBufferIfNecessary(int spare) {
-    if(buffer==null || buffer.remaining()<spare) {
-        growBuffer(Math.max(initialElementCount, spare));
+  protected final boolean growBufferIfNecessary(int spareComponents) {
+    if( buffer==null || buffer.remaining()<spareComponents ) {
+        if( 0 != mappedElementCount ) {
+            throw new GLException("Mapped buffer can't grow. Insufficient storage size: Needed "+spareComponents+" components, "+
+                                  "mappedElementCount "+mappedElementCount+
+                                  ", has mapped buffer "+buffer+"; "+this);
+        }
+        growBuffer(Math.max(initialElementCount, (spareComponents+componentsPerElement-1)/componentsPerElement));
         return true;
     }
     return false;
@@ -360,34 +368,35 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
     }
 
     // add the stride delta
-    additionalElements += (additionalElements/components)*(strideL-components);
+    additionalElements += (additionalElements/componentsPerElement)*(strideL-componentsPerElement);
 
     final int osize = (buffer!=null) ? buffer.capacity() : 0;
-    final int nsize = osize + ( additionalElements * components );
+    final int nsize = osize + ( additionalElements * componentsPerElement );
+    final Buffer oldBuffer = buffer;
 
     if(componentClazz==ByteBuffer.class) {
-        ByteBuffer newBBuffer = Buffers.newDirectByteBuffer( nsize );
+        final ByteBuffer newBBuffer = Buffers.newDirectByteBuffer( nsize );
         if(buffer!=null) {
             buffer.flip();
             newBBuffer.put((ByteBuffer)buffer);
         }
         buffer = newBBuffer;
     } else if(componentClazz==ShortBuffer.class) {
-        ShortBuffer newSBuffer = Buffers.newDirectShortBuffer( nsize );
+        final ShortBuffer newSBuffer = Buffers.newDirectShortBuffer( nsize );
         if(buffer!=null) {
             buffer.flip();
             newSBuffer.put((ShortBuffer)buffer);
         }
         buffer = newSBuffer;
     } else if(componentClazz==IntBuffer.class) {
-        IntBuffer newIBuffer = Buffers.newDirectIntBuffer( nsize );
+        final IntBuffer newIBuffer = Buffers.newDirectIntBuffer( nsize );
         if(buffer!=null) {
             buffer.flip();
             newIBuffer.put((IntBuffer)buffer);
         }
         buffer = newIBuffer;
     } else if(componentClazz==FloatBuffer.class) {
-        FloatBuffer newFBuffer = Buffers.newDirectFloatBuffer( nsize );
+        final FloatBuffer newFBuffer = Buffers.newDirectFloatBuffer( nsize );
         if(buffer!=null) {
             buffer.flip();
             newFBuffer.put((FloatBuffer)buffer);
@@ -397,7 +406,8 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
         throw new GLException("Given Buffer Class not supported: "+componentClazz+":\n\t"+this);
     }
     if(DEBUG) {
-        System.err.println("*** Grow: comps: "+components+", "+(osize/components)+"/"+osize+" -> "+(nsize/components)+"/"+nsize+", "+this);
+        System.err.println("*** Grow: comps: "+componentsPerElement+", "+(osize/componentsPerElement)+"/"+osize+" -> "+(nsize/componentsPerElement)+"/"+nsize+
+                           "; "+oldBuffer+" -> "+buffer+"; "+this);
     }
   }
 
@@ -415,20 +425,24 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData
   }
 
   protected void init(String name, int index, int comps, int dataType, boolean normalized, int stride, Buffer data,
-                      int initialElementCount, boolean isVertexAttribute, GLArrayHandler handler,
-                      int vboName, long vboOffset, int vboUsage, int vboTarget, boolean usesGLSL)
+                      int initialElementCount, int mappedElementCount, boolean isVertexAttribute,
+                      GLArrayHandler handler, int vboName, long vboOffset, int vboUsage, int vboTarget, boolean usesGLSL)
     throws GLException
   {
-    super.init(name, index, comps, dataType, normalized, stride, data, isVertexAttribute,
-               vboName, vboOffset, vboUsage, vboTarget);
+    super.init(name, index, comps, dataType, normalized, stride, data, mappedElementCount,
+               isVertexAttribute, vboName, vboOffset, vboUsage, vboTarget);
 
+    if( 0<mappedElementCount && 0<initialElementCount ) { // null!=buffer case validated in super.init(..)
+        throw new IllegalArgumentException("mappedElementCount:="+mappedElementCount+" specified, but passing non zero initialElementSize");
+    }
     this.initialElementCount = initialElementCount;
     this.glArrayHandler = handler;
     this.usesGLSL = usesGLSL;
     this.sealed=false;
     this.bufferEnabled=false;
     this.enableBufferAlways=false;
-    this.bufferWritten=false;
+    this.bufferWritten = ( 0 == mappedElementCount ) ? false : true;
+
     if(null==buffer && initialElementCount>0) {
         growBuffer(initialElementCount);
     }
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java
index 4a12ff1ae..833f1ccda 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java
@@ -29,11 +29,15 @@
 package com.jogamp.opengl.util;
 
 import java.nio.Buffer;
+import java.nio.ByteBuffer;
 import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
 
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2ES2;
 import javax.media.opengl.GLArrayData;
+import javax.media.opengl.GLBufferStorage;
 import javax.media.opengl.GLException;
 import javax.media.opengl.fixedfunc.GLPointerFuncUtil;
 
@@ -68,23 +72,23 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * see {@link GLPointerFuncUtil#getPredefinedArrayIndexName(int)}.
    *
    * @param index The GL array index
-   * @param comps The array component number
-   * @param dataType The array index GL data type
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param stride
+   * @param stride in bytes from one element to the other. If zero, compsPerElement * compSizeInBytes
    * @param buffer the user define data
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    *
    * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
    */
-  public static GLArrayDataServer createFixed(int index, int comps, int dataType, boolean normalized, int stride,
+  public static GLArrayDataServer createFixed(int index, int compsPerElement, int dataType, boolean normalized, int stride,
                                               Buffer buffer, int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads);
-    ads.init(null, index, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    ads.init(null, index, compsPerElement, dataType, normalized, stride, buffer, buffer.limit(), 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
     return ads;
   }
 
@@ -101,22 +105,22 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * see {@link GLPointerFuncUtil#getPredefinedArrayIndexName(int)}.
    *
    * @param index The GL array index
-   * @param comps The array component number
-   * @param dataType The array index GL data type
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
    * @param initialElementCount
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    *
    * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
    */
-  public static GLArrayDataServer createFixed(int index, int comps, int dataType, boolean normalized, int initialElementCount,
+  public static GLArrayDataServer createFixed(int index, int compsPerElement, int dataType, boolean normalized, int initialElementCount,
                                               int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads);
-    ads.init(null, index, comps, dataType, normalized, 0, null, initialElementCount, false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    ads.init(null, index, compsPerElement, dataType, normalized, 0, null, initialElementCount, 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
     return ads;
   }
 
@@ -124,20 +128,42 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * Create a VBO, using a custom GLSL array attribute name
    * and starting with a new created Buffer object with initialElementCount size
    * @param name  The custom name for the GL attribute
-   * @param comps The array component number
-   * @param dataType The array index GL data type
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
    * @param initialElementCount
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createGLSL(String name, int comps,
+  public static GLArrayDataServer createGLSL(String name, int compsPerElement,
                                              int dataType, boolean normalized, int initialElementCount, int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLSLArrayHandler(ads);
-    ads.init(name, -1, comps, dataType, normalized, 0, null, initialElementCount,
-             true, glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.init(name, -1, compsPerElement, dataType, normalized, 0, null, initialElementCount,
+             0 /* mappedElementCount */, true, glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    return ads;
+  }
+
+  /**
+   * Create a VBO, using a custom GLSL array attribute name
+   * intended for GPU buffer storage mapping, see {@link GLBufferStorage}, via {@link #mapStorage(GL, int)} and {@link #mapStorage(GL, long, long, int)}.
+   * @param name  The custom name for the GL attribute
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
+   * @param normalized Whether the data shall be normalized
+   * @param mappedElementCount
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   */
+  public static GLArrayDataServer createGLSLMapped(String name, int compsPerElement,
+                                                   int dataType, boolean normalized, int mappedElementCount, int vboUsage)
+    throws GLException
+  {
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLSLArrayHandler(ads);
+    ads.init(name, -1, compsPerElement, dataType, normalized, 0, null, 0 /* initialElementCount */,
+             mappedElementCount, true, glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.seal(true);
     return ads;
   }
 
@@ -145,22 +171,22 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * Create a VBO, using a custom GLSL array attribute name
    * and starting with a given Buffer object incl it's stride
    * @param name  The custom name for the GL attribute
-   * @param comps The array component number
-   * @param dataType The array index GL data type
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param stride
+   * @param stride in bytes from one element to the other. If zero, compsPerElement * compSizeInBytes
    * @param buffer the user define data
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createGLSL(String name, int comps,
+  public static GLArrayDataServer createGLSL(String name, int compsPerElement,
                                              int dataType, boolean normalized, int stride, Buffer buffer,
                                              int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLSLArrayHandler(ads);
-    ads.init(name, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), true, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.init(name, -1, compsPerElement, dataType, normalized, stride, buffer, buffer.limit(), 0 /* mappedElementCount */, true,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
     return ads;
   }
 
@@ -169,22 +195,22 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    *
    * Hence no index, name for a fixed function pipeline nor vertex attribute is given.
    *
-   * @param comps The array component number
-   * @param dataType The array index GL data type
-   * @param stride
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
+   * @param stride in bytes from one element to the other. If zero, compsPerElement * compSizeInBytes
    * @param buffer the user define data
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    * @param vboTarget {@link GL#GL_ELEMENT_ARRAY_BUFFER}, ..
    * {@link GL#glGenBuffers(int, int[], int)
    */
-  public static GLArrayDataServer createData(int comps, int dataType, int stride,
+  public static GLArrayDataServer createData(int compsPerElement, int dataType, int stride,
                                              Buffer buffer, int vboUsage, int vboTarget)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLDataArrayHandler(ads);
-    ads.init(null, -1, comps, dataType, false, stride, buffer, buffer.limit(), false, glArrayHandler,
-             0, 0, vboUsage, vboTarget, false);
+    ads.init(null, -1, compsPerElement, dataType, false, stride, buffer, buffer.limit(), 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, vboTarget, false);
     return ads;
   }
 
@@ -193,43 +219,89 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    *
    * Hence no index, name for a fixed function pipeline nor vertex attribute is given.
    *
-   * @param comps The array component number
-   * @param dataType The array index GL data type
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
    * @param initialElementCount
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    * @param vboTarget {@link GL#GL_ELEMENT_ARRAY_BUFFER}, ..
    */
-  public static GLArrayDataServer createData(int comps, int dataType, int initialElementCount,
+  public static GLArrayDataServer createData(int compsPerElement, int dataType, int initialElementCount,
                                              int vboUsage, int vboTarget)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLDataArrayHandler(ads);
-    ads.init(null, -1, comps, dataType, false, 0, null, initialElementCount, false, glArrayHandler,
-             0, 0, vboUsage, vboTarget, false);
+    ads.init(null, -1, compsPerElement, dataType, false, 0, null, initialElementCount, 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, vboTarget, false);
     return ads;
   }
 
+  /**
+   * Create a VBO data object for any target w/o render pipeline association, i.e. {@link GL#GL_ELEMENT_ARRAY_BUFFER},
+   * intended for GPU buffer storage mapping, see {@link GLBufferStorage}, via {@link #mapStorage(GL, int)} and {@link #mapStorage(GL, long, long, int)}.
+   * <p>
+   * No index, name for a fixed function pipeline nor vertex attribute is given.
+   * </p>
+   *
+   * @param compsPerElement component count per element
+   * @param dataType The component's OpenGL data type
+   * @param initialElementCount
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   * @param vboTarget {@link GL#GL_ELEMENT_ARRAY_BUFFER}, ..
+   */
+  public static GLArrayDataServer createDataMapped(int compsPerElement, int dataType, int mappedElementCount,
+                                                   int vboUsage, int vboTarget)
+    throws GLException
+  {
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLDataArrayHandler(ads);
+    ads.init(null, -1, compsPerElement, dataType, false, 0, null, 0 /* initialElementCount */, mappedElementCount, false,
+             glArrayHandler, 0, 0, vboUsage, vboTarget, false);
+    return ads;
+  }
 
   /**
    * Create a VBO for fixed function interleaved array data
    * starting with a new created Buffer object with initialElementCount size.
    * <p>User needs to <i>configure</i> the interleaved segments via {@link #addFixedSubArray(int, int, int)}.</p>
    *
-   * @param comps The total number of all interleaved components.
-   * @param dataType The array index GL data type
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param initialElementCount
+   * @param initialElementCount The initial number of all interleaved elements
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createFixedInterleaved(int comps, int dataType, boolean normalized, int initialElementCount,
+  public static GLArrayDataServer createFixedInterleaved(int compsPerElement, int dataType, boolean normalized, int initialElementCount,
                                               int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLArrayHandlerInterleaved(ads);
-    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, comps, dataType, false, 0, null, initialElementCount, false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, false, 0, null, initialElementCount, 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    return ads;
+  }
+
+  /**
+   * Create a VBO for fixed function interleaved array data
+   * intended for GPU buffer storage mapping, see {@link GLBufferStorage}, via {@link #mapStorage(GL, int)} and {@link #mapStorage(GL, long, long, int)}.
+   * <p>User needs to <i>configure</i> the interleaved segments via {@link #addFixedSubArray(int, int, int)}.</p>
+   *
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
+   * @param normalized Whether the data shall be normalized
+   * @param mappedElementCount The total number of all interleaved elements
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   */
+  public static GLArrayDataServer createFixedInterleavedMapped(int compsPerElement, int dataType, boolean normalized, int mappedElementCount,
+                                                               int vboUsage)
+    throws GLException
+  {
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLArrayHandlerInterleaved(ads);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, false, 0, null, 0 /* initialElementCount */, mappedElementCount, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    ads.seal(true);
     return ads;
   }
 
@@ -238,20 +310,21 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * starting with a given Buffer object incl it's stride
    * <p>User needs to <i>configure</i> the interleaved segments via {@link #addFixedSubArray(int, int, int)}.</p>
    *
-   * @param comps The total number of all interleaved components.
-   * @param dataType The array index GL data type
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param initialElementCount
+   * @param stride in bytes from one element of a sub-array to the other. If zero, compsPerElement * compSizeInBytes
+   * @param buffer The user define data of all interleaved elements
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createFixedInterleaved(int comps, int dataType, boolean normalized, int stride, Buffer buffer,
+  public static GLArrayDataServer createFixedInterleaved(int compsPerElement, int dataType, boolean normalized, int stride, Buffer buffer,
                                               int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLArrayHandlerInterleaved(ads);
-    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, normalized, stride, buffer, buffer.limit(), 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, false);
     return ads;
   }
 
@@ -259,14 +332,14 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * Configure a segment of this fixed function interleaved array (see {@link #createFixedInterleaved(int, int, boolean, int, int)}).
    * <p>
    * This method may be called several times as long the sum of interleaved components does not
-   * exceed the total number of components of the created interleaved array.</p>
+   * exceed the total component count of the created interleaved array.</p>
    * <p>
    * The memory of the the interleaved array is being used.</p>
    * <p>
    * Must be called before using the array, eg: {@link #seal(boolean)}, {@link #putf(float)}, .. </p>
    *
    * @param index The GL array index, maybe -1 if vboTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER}
-   * @param comps This interleaved array segment's component number
+   * @param comps This interleaved array segment's component count per element
    * @param vboTarget {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER}
    */
   public GLArrayData addFixedSubArray(int index, int comps, int vboTarget) {
@@ -277,10 +350,19 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
       if(usesGLSL) {
           throw new GLException("buffer uses GLSL");
       }
-      final GLArrayDataWrapper ad = GLArrayDataWrapper.createFixed(
-              index, comps, getComponentType(),
-              getNormalized(), getStride(), getBuffer(),
-              getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      final int subStrideB = ( 0 == getStride() ) ? getComponentCount() * getComponentSizeInBytes() : getStride();
+      final GLArrayDataWrapper ad;
+      if( 0 < mappedElementCount ) {
+          ad = GLArrayDataWrapper.createFixed(
+                  index, comps, getComponentType(),
+                  getNormalized(), subStrideB, mappedElementCount,
+                  getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      } else {
+          ad = GLArrayDataWrapper.createFixed(
+                  index, comps, getComponentType(),
+                  getNormalized(), subStrideB, getBuffer(),
+                  getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      }
       ad.setVBOEnabled(isVBO());
       interleavedOffset += comps * getComponentSizeInBytes();
       if(GL.GL_ARRAY_BUFFER == vboTarget) {
@@ -294,20 +376,42 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * starting with a new created Buffer object with initialElementCount size.
    * <p>User needs to <i>configure</i> the interleaved segments via {@link #addGLSLSubArray(int, int, int)}.</p>
    *
-   * @param comps The total number of all interleaved components.
-   * @param dataType The array index GL data type
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param initialElementCount
+   * @param initialElementCount The initial number of all interleaved elements
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createGLSLInterleaved(int comps, int dataType, boolean normalized, int initialElementCount,
-                                              int vboUsage)
+  public static GLArrayDataServer createGLSLInterleaved(int compsPerElement, int dataType, boolean normalized, int initialElementCount,
+                                                        int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLSLArrayHandlerInterleaved(ads);
-    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, comps, dataType, false, 0, null, initialElementCount, false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, normalized, 0, null, initialElementCount, 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    return ads;
+  }
+
+  /**
+   * Create a VBO for GLSL interleaved array data
+   * intended for GPU buffer storage mapping, see {@link GLBufferStorage}, via {@link #mapStorage(GL, int)} and {@link #mapStorage(GL, long, long, int)}.
+   * <p>User needs to <i>configure</i> the interleaved segments via {@link #addGLSLSubArray(int, int, int)}.</p>
+   *
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
+   * @param normalized Whether the data shall be normalized
+   * @param mappedElementCount The total number of all interleaved elements
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   */
+  public static GLArrayDataServer createGLSLInterleavedMapped(int compsPerElement, int dataType, boolean normalized, int mappedElementCount, int vboUsage)
+    throws GLException
+  {
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLSLArrayHandlerInterleaved(ads);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, normalized, 0, null, 0 /* initialElementCount */, mappedElementCount, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.seal(true);
     return ads;
   }
 
@@ -316,21 +420,21 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * starting with a given Buffer object incl it's stride
    * <p>User needs to <i>configure</i> the interleaved segments via {@link #addGLSLSubArray(int, int, int)}.</p>
    *
-   * @param comps The total number of all interleaved components.
-   * @param dataType The array index GL data type
+   * @param compsPerElement The total number of all interleaved components per element.
+   * @param dataType The component's OpenGL data type
    * @param normalized Whether the data shall be normalized
-   * @param stride
-   * @param buffer the user define data
+   * @param stride in bytes from one element of a sub-array to the other. If zero, compsPerElement * compSizeInBytes
+   * @param buffer The user define data of all interleaved elements
    * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
    */
-  public static GLArrayDataServer createGLSLInterleaved(int comps, int dataType, boolean normalized, int stride, Buffer buffer,
-                                              int vboUsage)
+  public static GLArrayDataServer createGLSLInterleaved(int compsPerElement, int dataType, boolean normalized, int stride, Buffer buffer,
+                                                        int vboUsage)
     throws GLException
   {
     GLArrayDataServer ads = new GLArrayDataServer();
     GLArrayHandler glArrayHandler = new GLSLArrayHandlerInterleaved(ads);
-    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler,
-             0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
+    ads.init(GLPointerFuncUtil.mgl_InterleaveArray, -1, compsPerElement, dataType, normalized, stride, buffer, buffer.limit(), 0 /* mappedElementCount */, false,
+             glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER, true);
     return ads;
   }
 
@@ -338,13 +442,13 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * Configure a segment of this GLSL interleaved array (see {@link #createGLSLInterleaved(int, int, boolean, int, int)}).
    * <p>
    * This method may be called several times as long the sum of interleaved components does not
-   * exceed the total number of components of the created interleaved array.</p>
+   * exceed the total component count of the created interleaved array.</p>
    * <p>
    * The memory of the the interleaved array is being used.</p>
    * <p>
    * Must be called before using the array, eg: {@link #seal(boolean)}, {@link #putf(float)}, .. </p>
    * @param name  The custom name for the GL attribute, maybe null if vboTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER}
-   * @param comps This interleaved array segment's component number
+   * @param comps This interleaved array segment's component count per element
    * @param vboTarget {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER}
    */
   public GLArrayData addGLSLSubArray(String name, int comps, int vboTarget) {
@@ -355,10 +459,19 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
       if(!usesGLSL) {
           throw new GLException("buffer uses fixed function");
       }
-      final GLArrayDataWrapper ad = GLArrayDataWrapper.createGLSL(
-              name, comps, getComponentType(),
-              getNormalized(), getStride(), getBuffer(),
-              getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      final int subStrideB = ( 0 == getStride() ) ? getComponentCount() * getComponentSizeInBytes() : getStride();
+      final GLArrayDataWrapper ad;
+      if( 0 < mappedElementCount ) {
+          ad = GLArrayDataWrapper.createGLSL(
+                  name, comps, getComponentType(),
+                  getNormalized(), subStrideB, mappedElementCount,
+                  getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      } else {
+          ad = GLArrayDataWrapper.createGLSL(
+                  name, comps, getComponentType(),
+                  getNormalized(), subStrideB, getBuffer(),
+                  getVBOName(), interleavedOffset, getVBOUsage(), vboTarget);
+      }
       ad.setVBOEnabled(isVBO());
       interleavedOffset += comps * getComponentSizeInBytes();
       if(GL.GL_ARRAY_BUFFER == vboTarget) {
@@ -407,11 +520,73 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
    * Only possible if buffer is defined.
    */
   @Override
-  public void    setVBOEnabled(boolean vboUsage) {
+  public void setVBOEnabled(boolean vboUsage) {
     checkSeal(false);
     super.setVBOEnabled(vboUsage);
   }
 
+  public GLBufferStorage mapStorage(GL gl, int access) {
+      if( null != this.getBuffer() ) {
+          throw new IllegalStateException("user buffer not null");
+      }
+      if( null != mappedStorage ) {
+          throw new IllegalStateException("already mapped: "+mappedStorage);
+      }
+      checkSeal(true);
+      bindBuffer(gl, true);
+      gl.glBufferData(getVBOTarget(), getSizeInBytes(), null, getVBOUsage());
+      final GLBufferStorage storage = gl.mapBuffer(getVBOTarget(), access);
+      setMappedBuffer(storage);
+      bindBuffer(gl, false);
+      seal(false);
+      rewind();
+      return storage;
+  }
+  public GLBufferStorage mapStorage(GL gl, long offset, long length, int access) {
+      if( null != this.getBuffer() ) {
+          throw new IllegalStateException("user buffer not null");
+      }
+      if( null != mappedStorage ) {
+          throw new IllegalStateException("already mapped: "+mappedStorage);
+      }
+      checkSeal(true);
+      bindBuffer(gl, true);
+      gl.glBufferData(getVBOTarget(), getSizeInBytes(), null, getVBOUsage());
+      final GLBufferStorage storage = gl.mapBufferRange(getVBOTarget(), offset, length, access);
+      setMappedBuffer(storage);
+      bindBuffer(gl, false);
+      seal(false);
+      rewind();
+      return storage;
+  }
+  private final void setMappedBuffer(GLBufferStorage storage) {
+      mappedStorage = storage;
+      final ByteBuffer bb = storage.getMappedBuffer();
+      if(componentClazz==ByteBuffer.class) {
+          buffer = bb;
+      } else if(componentClazz==ShortBuffer.class) {
+          buffer = bb.asShortBuffer();
+      } else if(componentClazz==IntBuffer.class) {
+          buffer = bb.asIntBuffer();
+      } else if(componentClazz==FloatBuffer.class) {
+          buffer = bb.asFloatBuffer();
+      } else {
+          throw new GLException("Given Buffer Class not supported: "+componentClazz+":\n\t"+this);
+      }
+  }
+
+  public void unmapStorage(GL gl) {
+      if( null == mappedStorage ) {
+          throw new IllegalStateException("not mapped");
+      }
+      mappedStorage = null;
+      buffer = null;
+      seal(true);
+      bindBuffer(gl, true);
+      gl.glUnmapBuffer(getVBOTarget());
+      bindBuffer(gl, false);
+  }
+
   @Override
   public String toString() {
     return "GLArrayDataServer["+name+
@@ -423,9 +598,11 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
                        ", dataType 0x"+Integer.toHexString(componentType)+
                        ", bufferClazz "+componentClazz+
                        ", elements "+getElementCount()+
-                       ", components "+components+
+                       ", components "+componentsPerElement+
                        ", stride "+strideB+"b "+strideL+"c"+
                        ", initialElementCount "+initialElementCount+
+                       ", mappedElementCount "+mappedElementCount+
+                       ", mappedStorage "+mappedStorage+
                        ", vboEnabled "+vboEnabled+
                        ", vboName "+vboName+
                        ", vboUsage 0x"+Integer.toHexString(vboUsage)+
@@ -445,13 +622,13 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
 
   @Override
   protected void init(String name, int index, int comps, int dataType, boolean normalized,
-                      int stride, Buffer data, int initialElementCount, boolean isVertexAttribute,
-                      GLArrayHandler glArrayHandler,
-                      int vboName, long vboOffset, int vboUsage, int vboTarget, boolean usesGLSL)
+                      int stride, Buffer data, int initialElementCount, int mappedElementCount,
+                      boolean isVertexAttribute,
+                      GLArrayHandler glArrayHandler, int vboName, long vboOffset, int vboUsage, int vboTarget, boolean usesGLSL)
     throws GLException
   {
-    super.init(name, index, comps, dataType, normalized, stride, data, initialElementCount, isVertexAttribute, glArrayHandler,
-               vboName, vboOffset, vboUsage, vboTarget, usesGLSL);
+    super.init(name, index, comps, dataType, normalized, stride, data, initialElementCount, mappedElementCount, isVertexAttribute,
+               glArrayHandler, vboName, vboOffset, vboUsage, vboTarget, usesGLSL);
 
     vboEnabled=true;
   }
@@ -483,8 +660,10 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE
   public GLArrayDataServer(GLArrayDataServer src) {
     super(src);
     this.interleavedOffset = src.interleavedOffset;
+    this.mappedStorage = src.mappedStorage;
   }
 
   private int interleavedOffset = 0;
+  private GLBufferStorage mappedStorage = null;
 }
 
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java
index 068ab5203..f617fed73 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java
@@ -71,8 +71,35 @@ public class GLArrayDataWrapper implements GLArrayData {
     throws GLException
   {
       GLArrayDataWrapper adc = new GLArrayDataWrapper();
-      adc.init(null, index, comps, dataType, normalized, stride, buffer, false,
-               vboName, vboOffset, vboUsage, vboTarget);
+      adc.init(null, index, comps, dataType, normalized, stride, buffer, 0 /* mappedElementCount */,
+               false, vboName, vboOffset, vboUsage, vboTarget);
+      return adc;
+  }
+
+  /**
+   * Create a VBO, using a predefined fixed function array index, wrapping the mapped data characteristics.
+   *
+   * @param index The GL array index
+   * @param comps The array component number
+   * @param dataType The array index GL data type
+   * @param normalized Whether the data shall be normalized
+   * @param stride
+   * @param mappedElementCount
+   * @param vboName
+   * @param vboOffset
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   * @param vboTarget {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER}
+   * @return the new create instance
+   *
+   * @throws GLException
+   */
+  public static GLArrayDataWrapper createFixed(int index, int comps, int dataType, boolean normalized, int stride,
+                                               int mappedElementCount, int vboName, long vboOffset, int vboUsage, int vboTarget)
+    throws GLException
+  {
+      GLArrayDataWrapper adc = new GLArrayDataWrapper();
+      adc.init(null, index, comps, dataType, normalized, stride, null, mappedElementCount,
+               false, vboName, vboOffset, vboUsage, vboTarget);
       return adc;
   }
 
@@ -97,8 +124,34 @@ public class GLArrayDataWrapper implements GLArrayData {
     throws GLException
   {
       GLArrayDataWrapper adc = new GLArrayDataWrapper();
-      adc.init(name, -1, comps, dataType, normalized, stride, buffer, true,
-              vboName, vboOffset, vboUsage, vboTarget);
+      adc.init(name, -1, comps, dataType, normalized, stride, buffer, 0  /* mappedElementCount */,
+              true, vboName, vboOffset, vboUsage, vboTarget);
+      return adc;
+  }
+
+  /**
+   * Create a VBO, using a custom GLSL array attribute name, wrapping the mapped data characteristics.
+   *
+   * @param name  The custom name for the GL attribute, maybe null if gpuBufferTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER}
+   * @param comps The array component number
+   * @param dataType The array index GL data type
+   * @param normalized Whether the data shall be normalized
+   * @param stride
+   * @param mappedElementCount
+   * @param vboName
+   * @param vboOffset
+   * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW}
+   * @param vboTarget {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER}
+   * @return the new create instance
+   * @throws GLException
+   */
+  public static GLArrayDataWrapper createGLSL(String name, int comps, int dataType, boolean normalized, int stride,
+                                              int mappedElementCount, int vboName, long vboOffset, int vboUsage, int vboTarget)
+    throws GLException
+  {
+      GLArrayDataWrapper adc = new GLArrayDataWrapper();
+      adc.init(name, -1, comps, dataType, normalized, stride, null, mappedElementCount,
+              true, vboName, vboOffset, vboUsage, vboTarget);
       return adc;
   }
 
@@ -179,10 +232,10 @@ public class GLArrayDataWrapper implements GLArrayData {
   public final int getVBOTarget() { return vboEnabled?vboTarget:0; }
 
   @Override
-  public final Buffer getBuffer() { return buffer; }
+  public Buffer getBuffer() { return buffer; }
 
   @Override
-  public final int getComponentCount() { return components; }
+  public final int getComponentCount() { return componentsPerElement; }
 
   @Override
   public final int getComponentType() { return componentType; }
@@ -192,14 +245,25 @@ public class GLArrayDataWrapper implements GLArrayData {
 
   @Override
   public final int getElementCount() {
-    if(null==buffer) return 0;
-    return ( buffer.position()==0 ) ? ( buffer.limit() / components ) : ( buffer.position() / components ) ;
+    if( 0 != mappedElementCount ) {
+        return mappedElementCount;
+    } else if( null != buffer ) {
+        final int remainingComponents = ( 0 == buffer.position() ) ? buffer.limit() : buffer.position();
+        return ( remainingComponents * componentByteSize ) / strideB ;
+    } else {
+        return 0;
+    }
   }
 
   @Override
   public final int getSizeInBytes() {
-    if(null==buffer) return 0;
-    return ( buffer.position()==0 ) ? ( buffer.limit() * componentByteSize ) : ( buffer.position() * componentByteSize ) ;
+    if( 0 != mappedElementCount ) {
+        return mappedElementCount * componentsPerElement * componentByteSize ;
+    } else if( null != buffer ) {
+        return ( buffer.position()==0 ) ? ( buffer.limit() * componentByteSize ) : ( buffer.position() * componentByteSize ) ;
+    } else {
+        return 0;
+    }
   }
 
   @Override
@@ -228,8 +292,9 @@ public class GLArrayDataWrapper implements GLArrayData {
                        ", dataType 0x"+Integer.toHexString(componentType)+
                        ", bufferClazz "+componentClazz+
                        ", elements "+getElementCount()+
-                       ", components "+components+
+                       ", components "+componentsPerElement+
                        ", stride "+strideB+"b "+strideL+"c"+
+                       ", mappedElementCount "+mappedElementCount+
                        ", buffer "+buffer+
                        ", vboEnabled "+vboEnabled+
                        ", vboName "+vboName+
@@ -299,12 +364,14 @@ public class GLArrayDataWrapper implements GLArrayData {
       this.vboTarget = vboTarget;
   }
 
-  protected void init(String name, int index, int components, int componentType,
-                      boolean normalized, int stride, Buffer data,
-                      boolean isVertexAttribute,
-                      int vboName, long vboOffset, int vboUsage, int vboTarget)
+  protected void init(String name, int index, int componentsPerElement, int componentType,
+                      boolean normalized, int stride, Buffer data, int mappedElementCount,
+                      boolean isVertexAttribute, int vboName, long vboOffset, int vboUsage, int vboTarget)
     throws GLException
   {
+    if( 0<mappedElementCount && null != data ) {
+        throw new IllegalArgumentException("mappedElementCount:="+mappedElementCount+" specified, but passing non null buffer");
+    }
     this.isVertexAttribute = isVertexAttribute;
     this.index = index;
     this.location = -1;
@@ -333,19 +400,20 @@ public class GLArrayDataWrapper implements GLArrayData {
     if(0 > componentByteSize) {
         throw new GLException("Given componentType not supported: "+componentType+":\n\t"+this);
     }
-    if(0 >= components) {
-        throw new GLException("Invalid number of components: " + components);
+    if(0 >= componentsPerElement) {
+        throw new GLException("Invalid number of components: " + componentsPerElement);
     }
-    this.components = components;
+    this.componentsPerElement = componentsPerElement;
 
-    if(0<stride && stride<components*componentByteSize) {
-        throw new GLException("stride ("+stride+") lower than component bytes, "+components+" * "+componentByteSize);
+    if(0<stride && stride<componentsPerElement*componentByteSize) {
+        throw new GLException("stride ("+stride+") lower than component bytes, "+componentsPerElement+" * "+componentByteSize);
     }
     if(0<stride && stride%componentByteSize!=0) {
         throw new GLException("stride ("+stride+") not a multiple of bpc "+componentByteSize);
     }
     this.buffer = data;
-    this.strideB=(0==stride)?components*componentByteSize:stride;
+    this.mappedElementCount = mappedElementCount;
+    this.strideB=(0==stride)?componentsPerElement*componentByteSize:stride;
     this.strideL=strideB/componentByteSize;
     this.vboName= vboName;
     this.vboEnabled= 0 != vboName ;
@@ -389,7 +457,7 @@ public class GLArrayDataWrapper implements GLArrayData {
     this.index = src.index;
     this.location = src.location;
     this.name = src.name;
-    this.components = src.components;
+    this.componentsPerElement = src.componentsPerElement;
     this.componentType = src.componentType;
     this.componentClazz = src.componentClazz;
     this.componentByteSize = src.componentByteSize;
@@ -405,6 +473,7 @@ public class GLArrayDataWrapper implements GLArrayData {
     } else {
         this.buffer = null;
     }
+    this.mappedElementCount = src.mappedElementCount;
     this.isVertexAttribute = src.isVertexAttribute;
     this.vboOffset = src.vboOffset;
     this.vboName = src.vboName;
@@ -417,14 +486,17 @@ public class GLArrayDataWrapper implements GLArrayData {
   protected int index;
   protected int location;
   protected String name;
-  protected int components;
+  protected int componentsPerElement;
   protected int componentType;
   protected Class<?> componentClazz;
   protected int componentByteSize;
   protected boolean normalized;
-  protected int strideB; // stride in bytes
-  protected int strideL; // stride in logical components
+  /** stride in bytes; strideB >= componentsPerElement * componentByteSize */
+  protected int strideB;
+  /** stride in logical components */
+  protected int strideL;
   protected Buffer buffer;
+  protected int mappedElementCount;
   protected boolean isVertexAttribute;
   protected long vboOffset;
   protected int vboName;