TileRenderer: Unify TileRenderer, add RandomTileRenderer (both utilizing GLPixelBuffer, and pre/post GLEventListener)

3 files changed, 630 insertions, 213 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/RandomTileRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/RandomTileRenderer.java
new file mode 100644
index 000000000..ac420da3d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/RandomTileRenderer.java
@@ -0,0 +1,367 @@
+/**
+ * Copyright 2013 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 com.jogamp.opengl.util;
+
+import javax.media.nativewindow.util.Dimension;
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES3;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLEventListener;
+
+import com.jogamp.opengl.util.GLPixelBuffer.GLPixelAttributes;
+
+/**
+ * Variation of {@link TileRenderer} w/o using fixed tiles but arbitrary rectangular regions. 
+ */
+public class RandomTileRenderer {
+    private final Dimension imageSize = new Dimension(0, 0);
+    private final GLPixelStorageModes psm = new GLPixelStorageModes();
+
+    private GLPixelBuffer imageBuffer;
+    private GLPixelBuffer tileBuffer;
+    private PMVMatrixCallback pmvMatrixCB = null;
+    private int tX = 0;
+    private int tY = 0;
+    private int tWidth = 0;
+    private int tHeight = 0;
+
+    private GLAutoDrawable glad;
+    private GLEventListener[] listeners;
+    private boolean[] listenersInit;
+    private GLEventListener glEventListenerPre = null;
+    private GLEventListener glEventListenerPost = null;
+    
+    public static interface PMVMatrixCallback {
+        void reshapePMVMatrix(GL gl, int tileX, int tileY, int tileWidth, int tileHeight, int imageWidth, int imageHeight);      
+    }
+
+    /**
+     * Creates a new TileRenderer object
+     */
+    public RandomTileRenderer() {
+    }
+
+    public final void setPMVMatrixCallback(PMVMatrixCallback pmvMatrixCB) {
+        assert ( null != pmvMatrixCB );
+        this.pmvMatrixCB = pmvMatrixCB; 
+    }
+
+    /**
+     * Specify a buffer the tiles to be copied to. This is not
+     * necessary for the creation of the final image, but useful if you
+     * want to inspect each tile in turn.
+     * 
+     * @param buffer The buffer itself. Must be large enough to contain a random tile
+     */
+    public final void setTileBuffer(GLPixelBuffer buffer) {
+        tileBuffer = buffer;
+    }
+
+    /** @see #setTileBuffer(GLPixelBuffer) */
+    public final GLPixelBuffer getTileBuffer() { return tileBuffer; }
+    
+    /**
+     * Sets the desired size of the final image
+     * 
+     * @param width
+     *           The width of the final image
+     * @param height
+     *           The height of the final image
+     */
+    public final void setImageSize(int width, int height) {
+        imageSize.setWidth(width);
+        imageSize.setHeight(height);
+    }
+    
+    /** @see #setImageSize(int, int) */
+    public final Dimension getImageSize() { return imageSize; }
+
+    /**
+     * Sets the buffer in which to store the final image
+     * 
+     * @param buffer the buffer itself, must be large enough to hold the final image
+     */
+    public final void setImageBuffer(GLPixelBuffer buffer) {
+        imageBuffer = buffer;
+    }
+
+    /** @see #setImageBuffer(GLPixelBuffer) */
+    public final GLPixelBuffer getImageBuffer() { return imageBuffer; }
+    
+    /**
+     * Begins rendering a tile.
+     * <p>
+     * Methods modifies the viewport, hence user shall reset the viewport when finishing tile rendering.
+     * </p>
+     * <p> 
+     * The projection matrix stack should be
+     * left alone after calling this method!
+     * </p>
+     * 
+     * @param gl The gl context
+     * @throws IllegalStateException
+     * @throws IllegalArgumentException
+     */
+    public final void beginTile(GL2ES3 gl, int tX, int tY, int tWidth, int tHeight) throws IllegalStateException, IllegalArgumentException {
+        if( 0 >= imageSize.getWidth() || 0 >= imageSize.getHeight() ) {
+            throw new IllegalStateException("Image size has not been set");        
+        }
+        if( null == this.pmvMatrixCB ) {
+            throw new IllegalStateException("pmvMatrixCB has not been set");        
+        }
+        if( 0 > tX || 0 > tX ) {
+            throw new IllegalArgumentException("Tile pos must be >= 0/0");        
+        }
+        if( 0 >= tWidth || 0 >= tHeight ) {
+            throw new IllegalArgumentException("Tile size must be > 0x0");        
+        }
+        
+        gl.glViewport( 0, 0, tWidth, tHeight );
+        pmvMatrixCB.reshapePMVMatrix(gl, tX, tY, tWidth, tHeight, imageSize.getWidth(), imageSize.getHeight());
+        
+        this.tX = tX;
+        this.tY = tY;
+        this.tWidth = tWidth;
+        this.tHeight = tHeight;
+    }
+    
+    /**
+     * Must be called after rendering the scene
+     * 
+     * @param gl
+     *           the gl context
+     * @return true if there are more tiles to be rendered, false if
+     *         the final image is complete
+     */
+    public void endTile( GL2ES3 gl )  {
+        if( 0 >= tWidth || 0 >= tHeight ) {
+            throw new IllegalStateException("beginTile(..) has not been called");
+        }
+        
+        // be sure OpenGL rendering is finished
+        gl.glFlush();
+
+        // save current glPixelStore values
+        psm.save(gl);
+
+        final int tmp[] = new int[1];
+
+        if( tileBuffer != null ) {
+            final GLPixelAttributes pixelAttribs = tileBuffer.pixelAttributes;
+            final int srcX = 0;
+            final int srcY = 0;
+            final int srcWidth = tWidth;
+            final int srcHeight = tHeight;
+            final int readPixelSize = GLBuffers.sizeof(gl, tmp, pixelAttribs.bytesPerPixel, srcWidth, srcHeight, 1, true);
+            tileBuffer.clear();
+            if( tileBuffer.requiresNewBuffer(gl, srcWidth, srcHeight, readPixelSize) ) {
+                throw new IndexOutOfBoundsException("Required " + readPixelSize + " bytes of buffer, only had " + tileBuffer);
+            }
+            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, pixelAttribs.format, pixelAttribs.type, tileBuffer.buffer);
+            // be sure OpenGL rendering is finished
+            gl.glFlush();
+            tileBuffer.position( readPixelSize );
+            tileBuffer.flip();
+        }
+
+        if( imageBuffer != null ) {
+            final GLPixelAttributes pixelAttribs = imageBuffer.pixelAttributes;
+            final int srcX = 0;
+            final int srcY = 0;
+            final int srcWidth = tWidth;
+            final int srcHeight = tHeight;
+
+            /* setup pixel store for glReadPixels */
+            final int rowLength = imageSize.getWidth();
+            psm.setPackRowLength(gl, rowLength);
+            psm.setPackAlignment(gl, 1);
+
+            /* read the tile into the final image */
+            final int readPixelSize = GLBuffers.sizeof(gl, tmp, pixelAttribs.bytesPerPixel, srcWidth, srcHeight, 1, true);
+
+            final int ibPos = ( tX + ( tY * rowLength ) ) * pixelAttribs.bytesPerPixel; // skipPixels + skipRows
+            final int ibLim = ibPos + readPixelSize;
+            imageBuffer.clear();
+            if( imageBuffer.requiresNewBuffer(gl, srcWidth, srcHeight, readPixelSize) ) {
+                throw new IndexOutOfBoundsException("Required " + ibLim + " bytes of buffer, only had " + imageBuffer);
+            }
+            imageBuffer.position(ibPos);
+
+            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, pixelAttribs.format, pixelAttribs.type, imageBuffer.buffer);
+            // be sure OpenGL rendering is finished
+            gl.glFlush();
+            imageBuffer.position( ibLim );
+            imageBuffer.flip();
+        }
+
+        /* restore previous glPixelStore values */
+        psm.restore(gl);
+
+        this.tX = 0;
+        this.tY = 0;
+        this.tWidth = 0;
+        this.tHeight = 0;
+    }
+    
+    /**
+     * 
+     * <p>
+     * Sets the size of the tiles to use in rendering. The actual
+     * effective size of the tile depends on the border size, ie (
+     * width - 2*border ) * ( height - 2 * border )
+     * </p>
+     * @param glad
+     * @throws IllegalStateException if an {@link GLAutoDrawable} is already attached
+     */
+    public void attachAutoDrawable(GLAutoDrawable glad, PMVMatrixCallback pmvMatrixCB) throws IllegalStateException {
+        if( null != this.glad ) {
+            throw new IllegalStateException("GLAutoDrawable already attached");
+        }
+        this.glad = glad;
+        setPMVMatrixCallback(pmvMatrixCB);
+        
+        final int aSz = glad.getGLEventListenerCount();
+        listeners = new GLEventListener[aSz];
+        listenersInit = new boolean[aSz];
+        for(int i=0; i<aSz; i++) {
+            final GLEventListener l = glad.getGLEventListener(0);
+            listenersInit[i] = glad.getGLEventListenerInitState(l);
+            listeners[i] = glad.removeGLEventListener( l );
+        }
+        glad.addGLEventListener(tiledGLEL);
+    }
+
+    public void detachAutoDrawable() {
+        if( null != glad ) {
+            glad.removeGLEventListener(tiledGLEL);
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                final GLEventListener l = listeners[i];
+                glad.addGLEventListener(l);
+                glad.setGLEventListenerInitState(l, listenersInit[i]);
+            }
+            listeners = null;
+            listenersInit = null;
+            glad = null;
+            pmvMatrixCB = null;
+        }
+    }
+
+    /**
+     * Set {@link GLEventListener} for pre- and post operations when used w/ 
+     * {@link #attachAutoDrawable(GLAutoDrawable, int, PMVMatrixCallback)}
+     * for each {@link GLEventListener} callback.
+     * @param preTile the pre operations
+     * @param postTile the post operations
+     */
+    public void setGLEventListener(GLEventListener preTile, GLEventListener postTile) {
+        glEventListenerPre = preTile;
+        glEventListenerPost = postTile;
+    }
+    
+    /**
+     * Rendering one tile, by simply calling {@link GLAutoDrawable#display()}.
+     * 
+     * @return true if there are more tiles to be rendered, false if the final image is complete
+     * @throws IllegalStateException if no {@link GLAutoDrawable} is {@link #attachAutoDrawable(GLAutoDrawable, int) attached}
+     *                               or imageSize is not set
+     */
+    public void display(int tX, int tY, int tWidth, int tHeight) throws IllegalStateException {
+        if( null == glad ) {
+            throw new IllegalStateException("No GLAutoDrawable attached");
+        }
+        this.tX = tX;
+        this.tY = tY;
+        this.tWidth = tWidth;
+        this.tHeight = tHeight;
+        glad.display();
+    }
+
+    private final GLEventListener tiledGLEL = new GLEventListener() {
+        @Override
+        public void init(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.init(drawable);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                final GLEventListener l = listeners[i];
+                l.init(drawable);
+                listenersInit[i] = true;
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.init(drawable);
+            }
+        }
+        @Override
+        public void dispose(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.dispose(drawable);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].dispose(drawable);
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.dispose(drawable);
+            }
+        }
+        @Override
+        public void display(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.display(drawable);
+            }
+            final GL2ES3 gl = drawable.getGL().getGL2ES3();
+
+            beginTile(gl, tX, tY, tWidth, tHeight);
+
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].display(drawable);
+            }
+
+            endTile(gl);
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.display(drawable);
+            }
+        }
+        @Override
+        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.reshape(drawable, x, y, width, height);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].reshape(drawable, x, y, width, height);
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.reshape(drawable, x, y, width, height);
+            }
+        }
+    };    
+}
\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java
index afd023224..c7c94c8da 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java
@@ -1,10 +1,48 @@
+/**
+ * Copyright 2013 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.
+ * 
+ * ---------------------
+ * 
+ * Based on Brian Paul's tile rendering library, found
+ * at <a href = "http://www.mesa3d.org/brianp/TR.html">http://www.mesa3d.org/brianp/TR.html</a>.
+ * 
+ * Copyright (C) 1997-2005 Brian Paul. 
+ * Licensed under BSD-compatible terms with permission of the author. 
+ * See LICENSE.txt for license information.
+ */
 package com.jogamp.opengl.util;
 
-import java.nio.ByteBuffer;
-
 import javax.media.nativewindow.util.Dimension;
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2ES3;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLEventListener;
+
+import com.jogamp.opengl.util.GLPixelBuffer.GLPixelAttributes;
 
 /**
  * A fairly direct port of Brian Paul's tile rendering library, found
@@ -23,12 +61,6 @@ import javax.media.opengl.GL2ES3;
  * @author ryanm, sgothel
  */
 public class TileRenderer {
-
-    protected static final boolean DEBUG = true;
-    protected static final int DEFAULT_TILE_WIDTH = 256;
-    protected static final int DEFAULT_TILE_HEIGHT = 256;
-    protected static final int DEFAULT_TILE_BORDER = 0;
-
     /**
      * The width of a tile
      */
@@ -86,29 +118,37 @@ public class TileRenderer {
      */
     public static final int TR_BOTTOM_TO_TOP = 2;
 
-    protected final Dimension imageSize = new Dimension(0, 0);
-    protected final Dimension tileSize = new Dimension(DEFAULT_TILE_WIDTH, DEFAULT_TILE_HEIGHT);
-    protected final Dimension tileSizeNB = new Dimension(DEFAULT_TILE_WIDTH - 2 * DEFAULT_TILE_BORDER, DEFAULT_TILE_HEIGHT - 2 * DEFAULT_TILE_BORDER);
-    protected final int[] userViewport = new int[ 4 ];
-    protected final GLPixelStorageModes psm = new GLPixelStorageModes();
-
-    protected int tileBorder = DEFAULT_TILE_BORDER;
-    protected int imageFormat;
-    protected int imageType;
-    protected ByteBuffer imageBuffer;
-    protected int tileFormat;
-    protected int tileType;
-    protected ByteBuffer tileBuffer;
-    protected int rowOrder = TR_BOTTOM_TO_TOP;
-    protected int rows;
-    protected int columns;
-    protected int currentTile = -1;
-    protected int currentTileWidth;
-    protected int currentTileHeight;
-    protected int currentRow;
-    protected int currentColumn;
-    protected PMVMatrixCallback pmvMatrixCB = null;
-
+    private static final boolean DEBUG = true;
+    private static final int DEFAULT_TILE_WIDTH = 256;
+    private static final int DEFAULT_TILE_HEIGHT = 256;
+    private static final int DEFAULT_TILE_BORDER = 0;
+
+    private final Dimension imageSize = new Dimension(0, 0);
+    private final Dimension tileSize = new Dimension(DEFAULT_TILE_WIDTH, DEFAULT_TILE_HEIGHT);
+    private final Dimension tileSizeNB = new Dimension(DEFAULT_TILE_WIDTH - 2 * DEFAULT_TILE_BORDER, DEFAULT_TILE_HEIGHT - 2 * DEFAULT_TILE_BORDER);
+    private final int[] userViewport = new int[ 4 ];
+    private final GLPixelStorageModes psm = new GLPixelStorageModes();
+
+    private int tileBorder = DEFAULT_TILE_BORDER;
+    private GLPixelBuffer imageBuffer;
+    private GLPixelBuffer tileBuffer;
+    private int rowOrder = TR_BOTTOM_TO_TOP;
+    private int rows;
+    private int columns;
+    private int currentTile = -1;
+    private int currentTileWidth;
+    private int currentTileHeight;
+    private int currentRow;
+    private int currentColumn;
+    private PMVMatrixCallback pmvMatrixCB = null;
+    private boolean beginCalled = false;
+
+    private GLAutoDrawable glad;
+    private GLEventListener[] listeners;
+    private boolean[] listenersInit;
+    private GLEventListener glEventListenerPre = null;
+    private GLEventListener glEventListenerPost = null;
+    
     public static interface PMVMatrixCallback {
         void reshapePMVMatrix(GL gl, int tileNum, int tileColumn, int tileRow, int tileX, int tileY, int tileWidth, int tileHeight, int imageWidth, int imageHeight);      
     }
@@ -136,12 +176,12 @@ public class TileRenderer {
      *           thickness > 1.
      */
     public final void setTileSize(int width, int height, int border) {
-        assert ( border >= 0 );
-        assert ( width >= 1 );
-        assert ( height >= 1 );
-        assert ( width >= 2 * border );
-        assert ( height >= 2 * border );
-
+        if( 0 > border ) {
+            throw new IllegalArgumentException("Tile border must be >= 0");        
+        }
+        if( 2 * border >= width || 2 * border >= height ) {
+            throw new IllegalArgumentException("Tile size must be > 0x0 minus 2*border");        
+        }
         tileBorder = border;
         tileSize.setWidth( width );
         tileSize.setHeight( height );
@@ -158,7 +198,7 @@ public class TileRenderer {
     /**
      * Sets up the number of rows and columns needed
      */
-    protected final void setup() throws IllegalStateException {
+    private final void setup() throws IllegalStateException {
         columns = ( imageSize.getWidth() + tileSizeNB.getWidth() - 1 ) / tileSizeNB.getWidth();
         rows = ( imageSize.getHeight() + tileSizeNB.getHeight() - 1 ) / tileSizeNB.getHeight();
         currentTile = 0;
@@ -182,20 +222,15 @@ public class TileRenderer {
      * necessary for the creation of the final image, but useful if you
      * want to inspect each tile in turn.
      * 
-     * @param format
-     *           Interpreted as in glReadPixels
-     * @param type
-     *           Interpreted as in glReadPixels
-     * @param buffer
-     *           The buffer itself. Must be large enough to contain a
-     *           tile, minus any borders
+     * @param buffer The buffer itself. Must be large enough to contain a tile, minus any borders
      */
-    public final void setTileBuffer(int format, int type, ByteBuffer buffer) {
-        tileFormat = format;
-        tileType = type;
+    public final void setTileBuffer(GLPixelBuffer buffer) {
         tileBuffer = buffer;
     }
 
+    /** @see #setTileBuffer(GLPixelBuffer) */
+    public final GLPixelBuffer getTileBuffer() { return tileBuffer; }
+
     /**
      * Sets the desired size of the final image
      * 
@@ -210,23 +245,21 @@ public class TileRenderer {
         setup();
     }
 
+    /** @see #setImageSize(int, int) */
+    public final Dimension getImageSize() { return imageSize; }
+    
     /**
      * Sets the buffer in which to store the final image
      * 
-     * @param format
-     *           Interpreted as in glReadPixels
-     * @param type
-     *           Interpreted as in glReadPixels
-     * @param image
-     *           the buffer itself, must be large enough to hold the
-     *           final image
+     * @param image the buffer itself, must be large enough to hold the final image
      */
-    public final void setImageBuffer(int format, int type, ByteBuffer buffer) {
-        imageFormat = format;
-        imageType = type;
+    public final void setImageBuffer(GLPixelBuffer buffer) {
         imageBuffer = buffer;
     }
 
+    /** @see #setImageBuffer(GLPixelBuffer) */
+    public final GLPixelBuffer getImageBuffer() { return imageBuffer; }
+    
     /**
      * Gets the parameters of this TileRenderer object
      * 
@@ -294,8 +327,9 @@ public class TileRenderer {
      * </p>
      * 
      * @param gl The gl context
+     * @throws IllegalStateException
      */
-    public final void beginTile( GL2ES3 gl ) {
+    public final void beginTile( GL2ES3 gl ) throws IllegalStateException {
         if( 0 >= imageSize.getWidth() || 0 >= imageSize.getHeight() ) {
             throw new IllegalStateException("Image size has not been set");        
         }
@@ -342,8 +376,8 @@ public class TileRenderer {
             tW = imageSize.getWidth() - ( columns - 1 ) * ( tileSizeNB.getWidth()  ) + 2 * border;
         }
 
-        final int tX = currentColumn * tileSizeNB.getWidth() - border;
-        final int tY = currentRow * tileSizeNB.getHeight() - border;
+        final int tX = currentColumn * tileSizeNB.getWidth();
+        final int tY = currentRow * tileSizeNB.getHeight();
 
         final int preTileWidth = currentTileWidth;
         final int preTileHeight = currentTileHeight;
@@ -359,6 +393,7 @@ public class TileRenderer {
 
         gl.glViewport( 0, 0, tW, tH );
         pmvMatrixCB.reshapePMVMatrix(gl, currentTile, currentColumn, currentRow, tX, tY, tW, tH, imageSize.getWidth(), imageSize.getHeight());
+        beginCalled = true;
     }
 
     /**
@@ -368,9 +403,12 @@ public class TileRenderer {
      *           the gl context
      * @return true if there are more tiles to be rendered, false if
      *         the final image is complete
+     * @throws IllegalStateException
      */
-    public boolean endTile( GL2ES3 gl )  {
-        assert ( currentTile >= 0 );
+    public boolean endTile( GL2ES3 gl ) throws IllegalStateException {
+        if( !beginCalled ) {
+            throw new IllegalStateException("beginTile(..) has not been called");
+        }
 
         // be sure OpenGL rendering is finished
         gl.glFlush();
@@ -381,17 +419,17 @@ public class TileRenderer {
         final int tmp[] = new int[1];
 
         if( tileBuffer != null ) {
-            int srcX = tileBorder;
-            int srcY = tileBorder;
-            int srcWidth = tileSizeNB.getWidth();
-            int srcHeight = tileSizeNB.getHeight();
-            final int bytesPerPixel = GLBuffers.bytesPerPixel(tileFormat, tileType);
-            final int readPixelSize = GLBuffers.sizeof(gl, tmp, bytesPerPixel, srcWidth, srcHeight, 1, true);
+            final GLPixelAttributes pixelAttribs = tileBuffer.pixelAttributes;
+            final int srcX = tileBorder;
+            final int srcY = tileBorder;
+            final int srcWidth = tileSizeNB.getWidth();
+            final int srcHeight = tileSizeNB.getHeight();
+            final int readPixelSize = GLBuffers.sizeof(gl, tmp, pixelAttribs.bytesPerPixel, srcWidth, srcHeight, 1, true);
             tileBuffer.clear();
-            if( tileBuffer.limit() < readPixelSize ) {
-                throw new IndexOutOfBoundsException("Required " + readPixelSize + " bytes of buffer, only had " + tileBuffer.limit());
+            if( tileBuffer.requiresNewBuffer(gl, srcWidth, srcHeight, readPixelSize) ) {
+                throw new IndexOutOfBoundsException("Required " + readPixelSize + " bytes of buffer, only had " + tileBuffer);
             }
-            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, tileFormat, tileType, tileBuffer );
+            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, pixelAttribs.format, pixelAttribs.type, tileBuffer.buffer);
             // be sure OpenGL rendering is finished
             gl.glFlush();
             tileBuffer.position( readPixelSize );
@@ -399,10 +437,11 @@ public class TileRenderer {
         }
 
         if( imageBuffer != null ) {
-            int srcX = tileBorder;
-            int srcY = tileBorder;
-            int srcWidth = currentTileWidth - 2 * tileBorder;
-            int srcHeight = currentTileHeight - 2 * tileBorder;
+            final GLPixelAttributes pixelAttribs = imageBuffer.pixelAttributes;
+            final int srcX = tileBorder;
+            final int srcY = tileBorder;
+            final int srcWidth = currentTileWidth - 2 * tileBorder;
+            final int srcHeight = currentTileHeight - 2 * tileBorder;
 
             /* setup pixel store for glReadPixels */
             final int rowLength = imageSize.getWidth();
@@ -410,20 +449,19 @@ public class TileRenderer {
             psm.setPackAlignment(gl, 1);
 
             /* read the tile into the final image */
-            final int bytesPerPixel = GLBuffers.bytesPerPixel(imageFormat, imageType);
-            final int readPixelSize = GLBuffers.sizeof(gl, tmp, bytesPerPixel, srcWidth, srcHeight, 1, true);
+            final int readPixelSize = GLBuffers.sizeof(gl, tmp, pixelAttribs.bytesPerPixel, srcWidth, srcHeight, 1, true);
 
-            final int skipPixels = tileSizeNB.getWidth() * currentColumn;
-            final int skipRows = tileSizeNB.getHeight() * currentRow;
-            final int ibPos = ( skipPixels + ( skipRows * rowLength ) ) * bytesPerPixel;
+            final int skipPixels = currentColumn * tileSizeNB.getWidth();
+            final int skipRows = currentRow * tileSizeNB.getHeight();
+            final int ibPos = ( skipPixels + ( skipRows * rowLength ) ) * pixelAttribs.bytesPerPixel;
             final int ibLim = ibPos + readPixelSize;
             imageBuffer.clear();
-            if( imageBuffer.limit() < ibLim ) {
-                throw new IndexOutOfBoundsException("Required " + ibLim + " bytes of buffer, only had " + imageBuffer.limit());
+            if( imageBuffer.requiresNewBuffer(gl, srcWidth, srcHeight, readPixelSize) ) {
+                throw new IndexOutOfBoundsException("Required " + ibLim + " bytes of buffer, only had " + imageBuffer);
             }
             imageBuffer.position(ibPos);
 
-            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, imageFormat, imageType, imageBuffer);
+            gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, pixelAttribs.format, pixelAttribs.type, imageBuffer.buffer);
             // be sure OpenGL rendering is finished
             gl.glFlush();
             imageBuffer.position( ibLim );
@@ -433,6 +471,8 @@ public class TileRenderer {
         /* restore previous glPixelStore values */
         psm.restore(gl);
 
+        beginCalled = false;
+        
         /* increment tile counter, return 1 if more tiles left to render */
         currentTile++;
         if( currentTile >= rows * columns ) {
@@ -444,4 +484,143 @@ public class TileRenderer {
             return true;
         }
     }
+    
+    /**
+     * 
+     * <p>
+     * Sets the size of the tiles to use in rendering. The actual
+     * effective size of the tile depends on the border size, ie (
+     * width - 2*border ) * ( height - 2 * border )
+     * </p>
+     * @param glad
+     * @param border
+     *           The width of the borders on each tile. This is needed
+     *           to avoid artifacts when rendering lines or points with
+     *           thickness > 1.
+     * @throws IllegalStateException if an {@link GLAutoDrawable} is already attached
+     */
+    public void attachAutoDrawable(GLAutoDrawable glad, int border, PMVMatrixCallback pmvMatrixCB) throws IllegalStateException {
+        if( null != this.glad ) {
+            throw new IllegalStateException("GLAutoDrawable already attached");
+        }
+        this.glad = glad;
+        setTileSize(glad.getWidth(), glad.getHeight(), border);
+        setPMVMatrixCallback(pmvMatrixCB);
+        
+        final int aSz = glad.getGLEventListenerCount();
+        listeners = new GLEventListener[aSz];
+        listenersInit = new boolean[aSz];
+        for(int i=0; i<aSz; i++) {
+            final GLEventListener l = glad.getGLEventListener(0);
+            listenersInit[i] = glad.getGLEventListenerInitState(l);
+            listeners[i] = glad.removeGLEventListener( l );
+        }
+        glad.addGLEventListener(tiledGLEL);
+    }
+
+    public void detachAutoDrawable() {
+        if( null != glad ) {
+            glad.removeGLEventListener(tiledGLEL);
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                final GLEventListener l = listeners[i];
+                glad.addGLEventListener(l);
+                glad.setGLEventListenerInitState(l, listenersInit[i]);
+            }
+            listeners = null;
+            listenersInit = null;
+            glad = null;
+            pmvMatrixCB = null;
+        }
+    }
+
+    /**
+     * Set {@link GLEventListener} for pre- and post operations when used w/ 
+     * {@link #attachAutoDrawable(GLAutoDrawable, int, PMVMatrixCallback)}
+     * for each {@link GLEventListener} callback.
+     * @param preTile the pre operations
+     * @param postTile the post operations
+     */
+    public void setGLEventListener(GLEventListener preTile, GLEventListener postTile) {
+        glEventListenerPre = preTile;
+        glEventListenerPost = postTile;
+    }
+    
+    /**
+     * Rendering one tile, by simply calling {@link GLAutoDrawable#display()}.
+     * 
+     * @return true if there are more tiles to be rendered, false if the final image is complete
+     * @throws IllegalStateException if no {@link GLAutoDrawable} is {@link #attachAutoDrawable(GLAutoDrawable, int) attached}
+     *                               or imageSize is not set
+     */
+    public boolean display() throws IllegalStateException {
+        if( null == glad ) {
+            throw new IllegalStateException("No GLAutoDrawable attached");
+        }
+        glad.display();
+        return !eot();
+    }
+
+    private final GLEventListener tiledGLEL = new GLEventListener() {
+        @Override
+        public void init(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.init(drawable);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                final GLEventListener l = listeners[i];
+                l.init(drawable);
+                listenersInit[i] = true;
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.init(drawable);
+            }
+        }
+        @Override
+        public void dispose(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.dispose(drawable);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].dispose(drawable);
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.dispose(drawable);
+            }
+        }
+        @Override
+        public void display(GLAutoDrawable drawable) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.display(drawable);
+            }
+            final GL2ES3 gl = drawable.getGL().getGL2ES3();
+
+            beginTile(gl);
+
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].display(drawable);
+            }
+
+            endTile(gl);
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.display(drawable);
+            }
+        }
+        @Override
+        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
+            if( null != glEventListenerPre ) {
+                glEventListenerPre.reshape(drawable, x, y, width, height);
+            }
+            final int aSz = listenersInit.length;
+            for(int i=0; i<aSz; i++) {
+                listeners[i].reshape(drawable, x, y, width, height);
+            }
+            if( null != glEventListenerPost ) {
+                glEventListenerPost.reshape(drawable, x, y, width, height);
+            }
+        }
+    };    
 }
\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/util/TileRenderer2.java b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer2.java
deleted file mode 100644
index a77456889..000000000
--- a/src/jogl/classes/com/jogamp/opengl/util/TileRenderer2.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package com.jogamp.opengl.util;
-
-import javax.media.opengl.GL2ES3;
-import javax.media.opengl.GLAutoDrawable;
-import javax.media.opengl.GLEventListener;
-
-/**
- * See {@link TileRenderer}.
- * <p>
- * Enhanced for {@link GLAutoDrawable} usage.
- * </p>
- */
-public class TileRenderer2 extends TileRenderer {
-    private GLAutoDrawable glad;
-    private GLEventListener[] listeners;
-    private boolean[] listenersInit;    
-
-    /**
-     * Creates a new TileRenderer object
-     */
-    public TileRenderer2() {
-        glad = null;
-        listeners = null;
-        listenersInit = null;
-    }
-
-    /**
-     * 
-     * <p>
-     * Sets the size of the tiles to use in rendering. The actual
-     * effective size of the tile depends on the border size, ie (
-     * width - 2*border ) * ( height - 2 * border )
-     * </p>
-     * @param glad
-     * @param border
-     *           The width of the borders on each tile. This is needed
-     *           to avoid artifacts when rendering lines or points with
-     *           thickness > 1.
-     * @throws IllegalStateException if an {@link GLAutoDrawable} is already attached
-     */
-    public void attachAutoDrawable(GLAutoDrawable glad, int border, PMVMatrixCallback pmvMatrixCB) throws IllegalStateException {
-        if( null != this.glad ) {
-            throw new IllegalStateException("GLAutoDrawable already attached");
-        }
-        this.glad = glad;
-        setTileSize(glad.getWidth(), glad.getHeight(), border);
-        setPMVMatrixCallback(pmvMatrixCB);
-        
-        final int aSz = glad.getGLEventListenerCount();
-        listeners = new GLEventListener[aSz];
-        listenersInit = new boolean[aSz];
-        for(int i=0; i<aSz; i++) {
-            final GLEventListener l = glad.getGLEventListener(0);
-            listenersInit[i] = glad.getGLEventListenerInitState(l);
-            listeners[i] = glad.removeGLEventListener( l );
-        }
-        glad.addGLEventListener(tiledGLEL);
-    }
-
-    public void detachAutoDrawable() {
-        if( null != glad ) {
-            glad.removeGLEventListener(tiledGLEL);
-            final int aSz = listenersInit.length;
-            for(int i=0; i<aSz; i++) {
-                final GLEventListener l = listeners[i];
-                glad.addGLEventListener(l);
-                glad.setGLEventListenerInitState(l, listenersInit[i]);
-            }
-            listeners = null;
-            listenersInit = null;
-            glad = null;
-            pmvMatrixCB = null;
-        }
-    }
-
-    /**
-     * Rendering one tile, by simply calling {@link GLAutoDrawable#display()}.
-     * 
-     * @return true if there are more tiles to be rendered, false if the final image is complete
-     * @throws IllegalStateException if no {@link GLAutoDrawable} is {@link #attachAutoDrawable(GLAutoDrawable, int) attached}
-     *                               or imageSize is not set
-     */
-    public boolean display() throws IllegalStateException {
-        if( null == glad ) {
-            throw new IllegalStateException("No GLAutoDrawable attached");
-        }
-        glad.display();
-        return !eot();
-    }
-
-    private final GLEventListener tiledGLEL = new GLEventListener() {
-        @Override
-        public void init(GLAutoDrawable drawable) {
-            final int aSz = listenersInit.length;
-            for(int i=0; i<aSz; i++) {
-                final GLEventListener l = listeners[i];
-                l.init(drawable);
-                listenersInit[i] = true;
-            }
-        }
-        @Override
-        public void dispose(GLAutoDrawable drawable) {
-            final int aSz = listenersInit.length;
-            for(int i=0; i<aSz; i++) {
-                listeners[i].dispose(drawable);
-            }
-        }
-        @Override
-        public void display(GLAutoDrawable drawable) {
-            final GL2ES3 gl = drawable.getGL().getGL2ES3();
-            
-            beginTile(gl);
-            
-            final int aSz = listenersInit.length;
-            for(int i=0; i<aSz; i++) {
-                listeners[i].display(drawable);
-            }
-            
-            endTile(gl);
-        }
-        @Override
-        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
-            final int aSz = listenersInit.length;
-            for(int i=0; i<aSz; i++) {
-                listeners[i].reshape(drawable, x, y, width, height);
-            }
-        }
-    };
-}