diff options
Diffstat (limited to 'src')
5 files changed, 883 insertions, 601 deletions
diff --git a/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java new file mode 100644 index 000000000..afd023224 --- /dev/null +++ b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer.java @@ -0,0 +1,447 @@ +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; + +/** + * A fairly direct port of 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> . I've java-fied it, but + * the functionality is the same. + * <p> + * Original code Copyright (C) 1997-2005 Brian Paul. Licensed under + * BSD-compatible terms with permission of the author. See LICENSE.txt + * for license information. + * </p> + * <p> + * Enhanced for {@link GL2ES3}. + * </p> + * + * @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 + */ + public static final int TR_TILE_WIDTH = 0; + /** + * The height of a tile + */ + public static final int TR_TILE_HEIGHT = 1; + /** + * The width of the border around the tiles + */ + public static final int TR_TILE_BORDER = 2; + /** + * The width of the final image + */ + public static final int TR_IMAGE_WIDTH = 3; + /** + * The height of the final image + */ + public static final int TR_IMAGE_HEIGHT = 4; + /** + * The number of rows of tiles + */ + public static final int TR_ROWS = 5; + /** + * The number of columns of tiles + */ + public static final int TR_COLUMNS = 6; + /** + * The current row number + */ + public static final int TR_CURRENT_ROW = 7; + /** + * The current column number + */ + public static final int TR_CURRENT_COLUMN = 8; + /** + * The width of the current tile + */ + public static final int TR_CURRENT_TILE_WIDTH = 9; + /** + * The height of the current tile + */ + public static final int TR_CURRENT_TILE_HEIGHT = 10; + /** + * The order that the rows are traversed + */ + public static final int TR_ROW_ORDER = 11; + /** + * Indicates we are traversing rows from the top to the bottom + */ + public static final int TR_TOP_TO_BOTTOM = 1; + /** + * Indicates we are traversing rows from the bottom to the top + */ + 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; + + 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); + } + + /** + * Creates a new TileRenderer object + */ + public TileRenderer() { + } + + /** + * 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 ) + * + * @param width + * The width of the tiles. Must not be larger than the GL + * context + * @param height + * The height of the tiles. Must not be larger than the + * GL context + * @param border + * The width of the borders on each tile. This is needed + * to avoid artifacts when rendering lines or points with + * 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 ); + + tileBorder = border; + tileSize.setWidth( width ); + tileSize.setHeight( height ); + tileSizeNB.setWidth( width - 2 * border ); + tileSizeNB.setHeight( height - 2 * border ); + setup(); + } + + public final void setPMVMatrixCallback(PMVMatrixCallback pmvMatrixCB) { + assert ( null != pmvMatrixCB ); + this.pmvMatrixCB = pmvMatrixCB; + } + + /** + * Sets up the number of rows and columns needed + */ + protected final void setup() throws IllegalStateException { + columns = ( imageSize.getWidth() + tileSizeNB.getWidth() - 1 ) / tileSizeNB.getWidth(); + rows = ( imageSize.getHeight() + tileSizeNB.getHeight() - 1 ) / tileSizeNB.getHeight(); + currentTile = 0; + currentTileWidth = 0; + currentTileHeight = 0; + currentRow = 0; + currentColumn = 0; + + assert columns >= 0; + assert rows >= 0; + } + + /** + * Returns <code>true</code> if all tiles have been rendered or {@link #setup()} + * has not been called, otherwise <code>false</code>. + */ + public final boolean eot() { return 0 > currentTile; } + + /** + * 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 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 + */ + public final void setTileBuffer(int format, int type, ByteBuffer buffer) { + tileFormat = format; + tileType = type; + tileBuffer = buffer; + } + + /** + * 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); + setup(); + } + + /** + * 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 + */ + public final void setImageBuffer(int format, int type, ByteBuffer buffer) { + imageFormat = format; + imageType = type; + imageBuffer = buffer; + } + + /** + * Gets the parameters of this TileRenderer object + * + * @param param + * The parameter that is to be retrieved + * @return the value of the parameter + */ + public final int getParam(int param) { + switch (param) { + case TR_TILE_WIDTH: + return tileSize.getWidth(); + case TR_TILE_HEIGHT: + return tileSize.getHeight(); + case TR_TILE_BORDER: + return tileBorder; + case TR_IMAGE_WIDTH: + return imageSize.getWidth(); + case TR_IMAGE_HEIGHT: + return imageSize.getHeight(); + case TR_ROWS: + return rows; + case TR_COLUMNS: + return columns; + case TR_CURRENT_ROW: + if( currentTile < 0 ) + return -1; + else + return currentRow; + case TR_CURRENT_COLUMN: + if( currentTile < 0 ) + return -1; + else + return currentColumn; + case TR_CURRENT_TILE_WIDTH: + return currentTileWidth; + case TR_CURRENT_TILE_HEIGHT: + return currentTileHeight; + case TR_ROW_ORDER: + return rowOrder; + default: + throw new IllegalArgumentException("Invalid enumerant as argument"); + } + } + + /** + * Sets the order of row traversal + * + * @param order + * The row traversal order, must be + * eitherTR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP + */ + public final void setRowOrder(int order) { + if (order == TR_TOP_TO_BOTTOM || order == TR_BOTTOM_TO_TOP) { + rowOrder = order; + } else { + throw new IllegalArgumentException("Must pass TR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP"); + } + } + + /** + * Begins rendering a tile. + * <p> + * The projection matrix stack should be + * left alone after calling this method! + * </p> + * + * @param gl The gl context + */ + public final void beginTile( GL2ES3 gl ) { + 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 (currentTile <= 0) { + setup(); + /* + * Save user's viewport, will be restored after last tile + * rendered + */ + gl.glGetIntegerv( GL.GL_VIEWPORT, userViewport, 0 ); + } + + final int preRow = currentRow; + final int preColumn = currentColumn; + + /* which tile (by row and column) we're about to render */ + if (rowOrder == TR_BOTTOM_TO_TOP) { + currentRow = currentTile / columns; + currentColumn = currentTile % columns; + } else { + currentRow = rows - ( currentTile / columns ) - 1; + currentColumn = currentTile % columns; + } + assert ( currentRow < rows ); + assert ( currentColumn < columns ); + + int border = tileBorder; + + int tH, tW; + + /* Compute actual size of this tile with border */ + if (currentRow < rows - 1) { + tH = tileSize.getHeight(); + } else { + tH = imageSize.getHeight() - ( rows - 1 ) * ( tileSizeNB.getHeight() ) + 2 * border; + } + + if (currentColumn < columns - 1) { + tW = tileSize.getWidth(); + } else { + 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 preTileWidth = currentTileWidth; + final int preTileHeight = currentTileHeight; + + /* Save tile size, with border */ + currentTileWidth = tW; + currentTileHeight = tH; + + if( DEBUG ) { + System.err.println("Tile["+currentTile+"]: ["+preColumn+"]["+preRow+"] "+preTileWidth+"x"+preTileHeight+ + " -> ["+currentColumn+"]["+currentRow+"] "+tX+"/"+tY+", "+tW+"x"+tH+", image "+imageSize.getWidth()+"x"+imageSize.getHeight()); + } + + gl.glViewport( 0, 0, tW, tH ); + pmvMatrixCB.reshapePMVMatrix(gl, currentTile, currentColumn, currentRow, tX, tY, tW, tH, imageSize.getWidth(), imageSize.getHeight()); + } + + /** + * 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 boolean endTile( GL2ES3 gl ) { + assert ( currentTile >= 0 ); + + // be sure OpenGL rendering is finished + gl.glFlush(); + + // save current glPixelStore values + psm.save(gl); + + 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); + tileBuffer.clear(); + if( tileBuffer.limit() < readPixelSize ) { + throw new IndexOutOfBoundsException("Required " + readPixelSize + " bytes of buffer, only had " + tileBuffer.limit()); + } + gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, tileFormat, tileType, tileBuffer ); + // be sure OpenGL rendering is finished + gl.glFlush(); + tileBuffer.position( readPixelSize ); + tileBuffer.flip(); + } + + if( imageBuffer != null ) { + int srcX = tileBorder; + int srcY = tileBorder; + int srcWidth = currentTileWidth - 2 * tileBorder; + int srcHeight = currentTileHeight - 2 * tileBorder; + + /* 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 bytesPerPixel = GLBuffers.bytesPerPixel(imageFormat, imageType); + final int readPixelSize = GLBuffers.sizeof(gl, tmp, 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 ibLim = ibPos + readPixelSize; + imageBuffer.clear(); + if( imageBuffer.limit() < ibLim ) { + throw new IndexOutOfBoundsException("Required " + ibLim + " bytes of buffer, only had " + imageBuffer.limit()); + } + imageBuffer.position(ibPos); + + gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, imageFormat, imageType, imageBuffer); + // be sure OpenGL rendering is finished + gl.glFlush(); + imageBuffer.position( ibLim ); + imageBuffer.flip(); + } + + /* restore previous glPixelStore values */ + psm.restore(gl); + + /* increment tile counter, return 1 if more tiles left to render */ + currentTile++; + if( currentTile >= rows * columns ) { + /* restore user's viewport */ + gl.glViewport( userViewport[ 0 ], userViewport[ 1 ], userViewport[ 2 ], userViewport[ 3 ] ); + currentTile = -1; /* all done */ + return false; + } else { + return true; + } + } +}
\ 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 new file mode 100644 index 000000000..a77456889 --- /dev/null +++ b/src/jogl/classes/com/jogamp/opengl/util/TileRenderer2.java @@ -0,0 +1,129 @@ +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); + } + } + }; +} diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java deleted file mode 100644 index 714c134d4..000000000 --- a/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java +++ /dev/null @@ -1,601 +0,0 @@ -package com.jogamp.opengl.util.gl2; - -import java.awt.Dimension; -import java.nio.Buffer; - -import javax.media.opengl.*; -import javax.media.opengl.glu.*; -import javax.media.opengl.glu.gl2.*; - -/** - * A fairly direct port of 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> . I've java-fied it, but - * the functionality is the same. - * - * Original code Copyright (C) 1997-2005 Brian Paul. Licensed under - * BSD-compatible terms with permission of the author. See LICENSE.txt - * for license information. - * - * @author ryanm - */ -public class TileRenderer -{ - private static final int DEFAULT_TILE_WIDTH = 256; - - private static final int DEFAULT_TILE_HEIGHT = 256; - - private static final int DEFAULT_TILE_BORDER = 0; - - // - // Enumeration flags for accessing variables - // - // @author ryanm - // - - /** - * The width of a tile - */ - public static final int TR_TILE_WIDTH = 0; - /** - * The height of a tile - */ - public static final int TR_TILE_HEIGHT = 1; - /** - * The width of the border around the tiles - */ - public static final int TR_TILE_BORDER = 2; - /** - * The width of the final image - */ - public static final int TR_IMAGE_WIDTH = 3; - /** - * The height of the final image - */ - public static final int TR_IMAGE_HEIGHT = 4; - /** - * The number of rows of tiles - */ - public static final int TR_ROWS = 5; - /** - * The number of columns of tiles - */ - public static final int TR_COLUMNS = 6; - /** - * The current row number - */ - public static final int TR_CURRENT_ROW = 7; - /** - * The current column number - */ - public static final int TR_CURRENT_COLUMN = 8; - /** - * The width of the current tile - */ - public static final int TR_CURRENT_TILE_WIDTH = 9; - /** - * The height of the current tile - */ - public static final int TR_CURRENT_TILE_HEIGHT = 10; - /** - * The order that the rows are traversed - */ - public static final int TR_ROW_ORDER = 11; - - - /** - * Indicates we are traversing rows from the top to the bottom - */ - public static final int TR_TOP_TO_BOTTOM = 1; - - /** - * Indicates we are traversing rows from the bottom to the top - */ - public static final int TR_BOTTOM_TO_TOP = 2; - - /* Final image parameters */ - private Dimension imageSize = new Dimension(); - - private int imageFormat, imageType; - - private Buffer imageBuffer; - - /* Tile parameters */ - private Dimension tileSize = new Dimension(); - - private Dimension tileSizeNB = new Dimension(); - - private int tileBorder; - - private int tileFormat, tileType; - - private Buffer tileBuffer; - - /* Projection parameters */ - private boolean perspective; - - private double left; - - private double right; - - private double bottom; - - private double top; - - private double near; - - private double far; - - /* Misc */ - private int rowOrder; - - private int rows, columns; - - private int currentTile; - - private int currentTileWidth, currentTileHeight; - - private int currentRow, currentColumn; - - private int[] viewportSave = new int[ 4 ]; - - /** - * Creates a new TileRenderer object - */ - public TileRenderer() - { - tileSize.width = DEFAULT_TILE_WIDTH; - tileSize.height = DEFAULT_TILE_HEIGHT; - tileBorder = DEFAULT_TILE_BORDER; - rowOrder = TR_BOTTOM_TO_TOP; - currentTile = -1; - } - - /** - * Sets up the number of rows and columns needed - */ - private void setup() - { - columns = ( imageSize.width + tileSizeNB.width - 1 ) / tileSizeNB.width; - rows = ( imageSize.height + tileSizeNB.height - 1 ) / tileSizeNB.height; - currentTile = 0; - - assert columns >= 0; - assert rows >= 0; - } - - /** - * 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 ) - * - * @param width - * The width of the tiles. Must not be larger than the GL - * context - * @param height - * The height of the tiles. Must not be larger than the - * GL context - * @param border - * The width of the borders on each tile. This is needed - * to avoid artifacts when rendering lines or points with - * thickness > 1. - */ - public 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 ); - - tileBorder = border; - tileSize.width = width; - tileSize.height = height; - tileSizeNB.width = width - 2 * border; - tileSizeNB.height = height - 2 * border; - setup(); - } - - /** - * 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 format - * Interpreted as in glReadPixels - * @param type - * Interpreted as in glReadPixels - * @param image - * The buffer itself. Must be large enough to contain a - * tile, minus any borders - */ - public void setTileBuffer( int format, int type, Buffer image ) - { - tileFormat = format; - tileType = type; - tileBuffer = image; - } - - /** - * 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 void setImageSize( int width, int height ) - { - imageSize.width = width; - imageSize.height = height; - setup(); - } - - /** - * 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 - */ - public void setImageBuffer( int format, int type, Buffer image ) - { - imageFormat = format; - imageType = type; - imageBuffer = image; - } - - /** - * Gets the parameters of this TileRenderer object - * - * @param param - * The parameter that is to be retrieved - * @return the value of the parameter - */ - public int getParam( int param ) - { - switch (param) { - case TR_TILE_WIDTH: - return tileSize.width; - case TR_TILE_HEIGHT: - return tileSize.height; - case TR_TILE_BORDER: - return tileBorder; - case TR_IMAGE_WIDTH: - return imageSize.width; - case TR_IMAGE_HEIGHT: - return imageSize.height; - case TR_ROWS: - return rows; - case TR_COLUMNS: - return columns; - case TR_CURRENT_ROW: - if( currentTile < 0 ) - return -1; - else - return currentRow; - case TR_CURRENT_COLUMN: - if( currentTile < 0 ) - return -1; - else - return currentColumn; - case TR_CURRENT_TILE_WIDTH: - return currentTileWidth; - case TR_CURRENT_TILE_HEIGHT: - return currentTileHeight; - case TR_ROW_ORDER: - return rowOrder; - default: - throw new IllegalArgumentException("Invalid enumerant as argument"); - } - } - - /** - * Sets the order of row traversal - * - * @param order - * The row traversal order, must be - * eitherTR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP - */ - public void setRowOrder( int order ) - { - if (order == TR_TOP_TO_BOTTOM || order == TR_BOTTOM_TO_TOP) { - rowOrder = order; - } else { - throw new IllegalArgumentException("Must pass TR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP"); - } - } - - /** - * Sets the context to use an orthographic projection. Must be - * called before rendering the first tile - * - * @param left - * As in glOrtho - * @param right - * As in glOrtho - * @param bottom - * As in glOrtho - * @param top - * As in glOrtho - * @param zNear - * As in glOrtho - * @param zFar - * As in glOrtho - */ - public void trOrtho( double left, double right, double bottom, double top, double zNear, - double zFar ) - { - this.perspective = false; - this.left = left; - this.right = right; - this.bottom = bottom; - this.top = top; - this.near = zNear; - this.far = zFar; - } - - /** - * Sets the perspective projection frustrum. Must be called before - * rendering the first tile - * - * @param left - * As in glFrustrum - * @param right - * As in glFrustrum - * @param bottom - * As in glFrustrum - * @param top - * As in glFrustrum - * @param zNear - * As in glFrustrum - * @param zFar - * As in glFrustrum - */ - public void trFrustum( double left, double right, double bottom, double top, double zNear, - double zFar ) - { - this.perspective = true; - this.left = left; - this.right = right; - this.bottom = bottom; - this.top = top; - this.near = zNear; - this.far = zFar; - } - - /** - * Convenient way to specify a perspective projection - * - * @param fovy - * As in gluPerspective - * @param aspect - * As in gluPerspective - * @param zNear - * As in gluPerspective - * @param zFar - * As in gluPerspective - */ - public void trPerspective( double fovy, double aspect, double zNear, double zFar ) - { - double xmin, xmax, ymin, ymax; - ymax = zNear * Math.tan( fovy * 3.14159265 / 360.0 ); - ymin = -ymax; - xmin = ymin * aspect; - xmax = ymax * aspect; - trFrustum( xmin, xmax, ymin, ymax, zNear, zFar ); - } - - /** - * Begins rendering a tile. The projection matrix stack should be - * left alone after calling this - * - * @param gl - * The gl context - */ - public void beginTile( GL2 gl ) - { - if (currentTile <= 0) { - setup(); - /* - * Save user's viewport, will be restored after last tile - * rendered - */ - gl.glGetIntegerv( GL2.GL_VIEWPORT, viewportSave, 0 ); - } - - /* which tile (by row and column) we're about to render */ - if (rowOrder == TR_BOTTOM_TO_TOP) { - currentRow = currentTile / columns; - currentColumn = currentTile % columns; - } else { - currentRow = rows - ( currentTile / columns ) - 1; - currentColumn = currentTile % columns; - } - assert ( currentRow < rows ); - assert ( currentColumn < columns ); - - int border = tileBorder; - - int th, tw; - - /* Compute actual size of this tile with border */ - if (currentRow < rows - 1) { - th = tileSize.height; - } else { - th = imageSize.height - ( rows - 1 ) * ( tileSizeNB.height ) + 2 * border; - } - - if (currentColumn < columns - 1) { - tw = tileSize.width; - } else { - tw = imageSize.width - ( columns - 1 ) * ( tileSizeNB.width ) + 2 * border; - } - - /* Save tile size, with border */ - currentTileWidth = tw; - currentTileHeight = th; - - gl.glViewport( 0, 0, tw, th ); - - /* save current matrix mode */ - int[] matrixMode = new int[ 1 ]; - gl.glGetIntegerv( GL2.GL_MATRIX_MODE, matrixMode, 0 ); - gl.glMatrixMode( GL2.GL_PROJECTION ); - gl.glLoadIdentity(); - - /* compute projection parameters */ - double l = - left + ( right - left ) * ( currentColumn * tileSizeNB.width - border ) - / imageSize.width; - double r = l + ( right - left ) * tw / imageSize.width; - double b = - bottom + ( top - bottom ) * ( currentRow * tileSizeNB.height - border ) - / imageSize.height; - double t = b + ( top - bottom ) * th / imageSize.height; - - if( perspective ) { - gl.glFrustum( l, r, b, t, near, far ); - } else { - gl.glOrtho( l, r, b, t, near, far ); - } - - /* restore user's matrix mode */ - gl.glMatrixMode( matrixMode[ 0 ] ); - } - - /** - * 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 boolean endTile( GL2 gl ) - { - int[] prevRowLength = new int[ 1 ], prevSkipRows = new int[ 1 ], prevSkipPixels = new int[ 1 ], prevAlignment = - new int[ 1 ]; - - assert ( currentTile >= 0 ); - - // be sure OpenGL rendering is finished - gl.glFlush(); - - // save current glPixelStore values - gl.glGetIntegerv( GL2.GL_PACK_ROW_LENGTH, prevRowLength, 0 ); - gl.glGetIntegerv( GL2.GL_PACK_SKIP_ROWS, prevSkipRows, 0 ); - gl.glGetIntegerv( GL2.GL_PACK_SKIP_PIXELS, prevSkipPixels, 0 ); - gl.glGetIntegerv( GL2.GL_PACK_ALIGNMENT, prevAlignment, 0 ); - - if( tileBuffer != null ) { - int srcX = tileBorder; - int srcY = tileBorder; - int srcWidth = tileSizeNB.width; - int srcHeight = tileSizeNB.height; - gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, tileFormat, tileType, tileBuffer ); - } - - if( imageBuffer != null ) { - int srcX = tileBorder; - int srcY = tileBorder; - int srcWidth = currentTileWidth - 2 * tileBorder; - int srcHeight = currentTileHeight - 2 * tileBorder; - int destX = tileSizeNB.width * currentColumn; - int destY = tileSizeNB.height * currentRow; - - /* setup pixel store for glReadPixels */ - gl.glPixelStorei( GL2.GL_PACK_ROW_LENGTH, imageSize.width ); - gl.glPixelStorei( GL2.GL_PACK_SKIP_ROWS, destY ); - gl.glPixelStorei( GL2.GL_PACK_SKIP_PIXELS, destX ); - gl.glPixelStorei( GL2.GL_PACK_ALIGNMENT, 1 ); - - /* read the tile into the final image */ - gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, imageFormat, imageType, imageBuffer ); - } - - /* restore previous glPixelStore values */ - gl.glPixelStorei( GL2.GL_PACK_ROW_LENGTH, prevRowLength[ 0 ] ); - gl.glPixelStorei( GL2.GL_PACK_SKIP_ROWS, prevSkipRows[ 0 ] ); - gl.glPixelStorei( GL2.GL_PACK_SKIP_PIXELS, prevSkipPixels[ 0 ] ); - gl.glPixelStorei( GL2.GL_PACK_ALIGNMENT, prevAlignment[ 0 ] ); - - /* increment tile counter, return 1 if more tiles left to render */ - currentTile++; - if( currentTile >= rows * columns ) { - /* restore user's viewport */ - gl.glViewport( viewportSave[ 0 ], viewportSave[ 1 ], viewportSave[ 2 ], viewportSave[ 3 ] ); - currentTile = -1; /* all done */ - return false; - } else { - return true; - } - } - - /** - * Tile rendering causes problems with using glRasterPos3f, so you - * should use this replacement instead - * - * @param x - * As in glRasterPos3f - * @param y - * As in glRasterPos3f - * @param z - * As in glRasterPos3f - * @param gl - * The gl context - * @param glu - * A GLUgl2 object - */ - public void trRasterPos3f( float x, float y, float z, GL2 gl, GLUgl2 glu ) - { - if (currentTile < 0) { - /* not doing tile rendering right now. Let OpenGL do this. */ - gl.glRasterPos3f( x, y, z ); - } else { - double[] modelview = new double[ 16 ], proj = new double[ 16 ]; - int[] viewport = new int[ 4 ]; - double[] win = new double[3]; - - /* Get modelview, projection and viewport */ - gl.glGetDoublev( GL2.GL_MODELVIEW_MATRIX, modelview, 0 ); - gl.glGetDoublev( GL2.GL_PROJECTION_MATRIX, proj, 0 ); - viewport[ 0 ] = 0; - viewport[ 1 ] = 0; - viewport[ 2 ] = currentTileWidth; - viewport[ 3 ] = currentTileHeight; - - /* Project object coord to window coordinate */ - if( glu.gluProject( x, y, z, modelview, 0, proj, 0, viewport, 0, win, 0 ) ) { - - /* set raster pos to window coord (0,0) */ - gl.glMatrixMode( GL2.GL_MODELVIEW ); - gl.glPushMatrix(); - gl.glLoadIdentity(); - gl.glMatrixMode( GL2.GL_PROJECTION ); - gl.glPushMatrix(); - gl.glLoadIdentity(); - gl.glOrtho( 0.0, currentTileWidth, 0.0, currentTileHeight, 0.0, 1.0 ); - gl.glRasterPos3d( 0.0, 0.0, -win[ 2 ] ); - - /* - * Now use empty bitmap to adjust raster position to - * (winX,winY) - */ - { - byte[] bitmap = { 0 }; - gl.glBitmap( 1, 1, 0.0f, 0.0f, ( float ) win[ 0 ], ( float ) win[ 1 ], bitmap , 0 ); - } - - /* restore original matrices */ - gl.glPopMatrix(); /* proj */ - gl.glMatrixMode( GL2.GL_MODELVIEW ); - gl.glPopMatrix(); - } - } - } -} diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering1GL2.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering1GL2.java new file mode 100644 index 000000000..05da3d71b --- /dev/null +++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering1GL2.java @@ -0,0 +1,172 @@ +package com.jogamp.opengl.test.junit.jogl.demos.gl2; + +import com.jogamp.common.util.IOUtil; +import com.jogamp.opengl.util.TGAWriter; +import com.jogamp.opengl.util.TileRenderer; +import com.jogamp.opengl.util.awt.ImageUtil; +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferByte; +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import javax.imageio.ImageIO; +import javax.media.opengl.GL; +import javax.media.opengl.GL2; +import javax.media.opengl.GLAutoDrawable; +import javax.media.opengl.GLCapabilities; +import javax.media.opengl.GLDrawableFactory; +import javax.media.opengl.GLEventListener; +import javax.media.opengl.GLOffscreenAutoDrawable; + +/** Demonstrates the TileRenderer class by rendering a large version + of the Gears demo to the specified file. */ + +public class TestTiledRendering1GL2 { + + public static void main(String[] args) throws IOException { + + if (args.length != 1) { + System.out.println("Usage: java TiledRendering [output file name]"); + System.out.println("Writes output (a large version of the Gears demo) to"); + System.out.println("the specified file, using either ImageIO or the fast TGA writer"); + System.out.println("depending on the file extension."); + System.exit(1); + } + + String filename = args[0]; + File file = new File(filename); + + GLCapabilities caps = new GLCapabilities(null); + caps.setDoubleBuffered(false); + + if (!GLDrawableFactory.getFactory(caps.getGLProfile()).canCreateGLPbuffer(null, caps.getGLProfile())) { + System.out.println("Demo requires pbuffer support"); + System.exit(1); + } + + // Use a pbuffer for rendering + final GLDrawableFactory factory = GLDrawableFactory.getFactory(caps.getGLProfile()); + final GLOffscreenAutoDrawable glad = factory.createOffscreenAutoDrawable(null, caps, null, 256, 256, null); + + // Fix the image size for now + // final int imageWidth = glad.getWidth() * 16; + // final int imageHeight = glad.getHeight() * 12; + final int imageWidth = glad.getWidth() * 2; + final int imageHeight = glad.getHeight() * 2; + + System.err.println("XXX1: "+imageWidth+"x"+imageHeight); + System.err.println("XXX1: "+glad); + + // Figure out the file format + TGAWriter tga = null; + BufferedImage img = null; + ByteBuffer buf = null; + + if (filename.endsWith(".tga")) { + tga = new TGAWriter(); + tga.open(file, + imageWidth, + imageHeight, + false); + buf = tga.getImageData(); + } else { + img = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_3BYTE_BGR); + buf = ByteBuffer.wrap(((DataBufferByte) img.getRaster().getDataBuffer()).getData()); + } + + // Initialize the tile rendering library + final TileRenderer renderer = new com.jogamp.opengl.util.TileRenderer(); + final TileRenderer.PMVMatrixCallback pmvMatrixCallback = new TileRenderer.PMVMatrixCallback() { + public void reshapePMVMatrix(GL _gl, int tileNum, int tileColumn, int tileRow, int tileX, int tileY, int tileWidth, int tileHeight, int imageWidth, int imageHeight) { + final GL2 gl = _gl.getGL2(); + gl.glMatrixMode( GL2.GL_PROJECTION ); + gl.glLoadIdentity(); + + /* compute projection parameters */ + float left, right, bottom, top; + if( imageHeight > imageWidth ) { + float a = (float)imageHeight / (float)imageWidth; + left = -1.0f; + right = 1.0f; + bottom = -a; + top = a; + } else { + float a = (float)imageWidth / (float)imageHeight; + left = -a; + right = a; + bottom = -1.0f; + top = 1.0f; + } + final float w = right - left; + final float h = top - bottom; + final float l = left + w * tileX / imageWidth; + final float r = l + w * tileWidth / imageWidth; + final float b = bottom + h * tileY / imageHeight; + final float t = b + h * tileHeight / imageHeight; + + final float _w = r - l; + final float _h = t - b; + System.err.println(">> [l "+left+", r "+right+", b "+bottom+", t "+top+"] "+w+"x"+h+" -> [l "+l+", r "+r+", b "+b+", t "+t+"] "+_w+"x"+_h); + gl.glFrustum(l, r, b, t, 5.0f, 60.0f); + + gl.glMatrixMode(GL2.GL_MODELVIEW); + } + }; + + renderer.setTileSize(glad.getWidth(), glad.getHeight(), 0); + renderer.setPMVMatrixCallback(pmvMatrixCallback); + renderer.setImageSize(imageWidth, imageHeight); + renderer.setImageBuffer(GL2.GL_BGR, GL.GL_UNSIGNED_BYTE, buf); + + glad.addGLEventListener( new GLEventListener() { + @Override + public void init(GLAutoDrawable drawable) { + System.err.println("XXX2: "+drawable); + } + @Override + public void dispose(GLAutoDrawable drawable) { + } + @Override + public void display(GLAutoDrawable drawable) { + renderer.beginTile(drawable.getGL().getGL2()); + } + @Override + public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { + } + }); + final Gears gears = new Gears(); + gears.setDoRotation(false); + glad.addGLEventListener( gears ); + glad.addGLEventListener( new GLEventListener() { + @Override + public void init(GLAutoDrawable drawable) { + } + @Override + public void dispose(GLAutoDrawable drawable) { + } + @Override + public void display(GLAutoDrawable drawable) { + renderer.endTile(drawable.getGL().getGL2()); + } + @Override + public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { + } + }); + + do { + glad.display(); + } while ( !renderer.eot() ); + + glad.destroy(); + + // Close things up and/or write image using ImageIO + if (tga != null) { + tga.close(); + } else { + ImageUtil.flipImageVertically(img); + if (!ImageIO.write(img, IOUtil.getFileSuffix(file), file)) { + System.err.println("Error writing file using ImageIO (unsupported file format?)"); + } + } + } +} diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering2GL2.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering2GL2.java new file mode 100644 index 000000000..2f04f5a0c --- /dev/null +++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/gl2/TestTiledRendering2GL2.java @@ -0,0 +1,135 @@ +package com.jogamp.opengl.test.junit.jogl.demos.gl2; + +import com.jogamp.common.util.IOUtil; +import com.jogamp.opengl.util.TGAWriter; +import com.jogamp.opengl.util.TileRenderer; +import com.jogamp.opengl.util.TileRenderer2; + +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferByte; +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import javax.imageio.ImageIO; +import javax.media.opengl.GL; +import javax.media.opengl.GL2; +import javax.media.opengl.GLCapabilities; +import javax.media.opengl.GLDrawableFactory; +import javax.media.opengl.GLOffscreenAutoDrawable; + +/** Demonstrates the TileRenderer class by rendering a large version + of the Gears demo to the specified file. */ + +public class TestTiledRendering2GL2 { + + public static void main(String[] args) throws IOException { + + if (args.length != 1) { + System.out.println("Usage: java TiledRendering [output file name]"); + System.out.println("Writes output (a large version of the Gears demo) to"); + System.out.println("the specified file, using either ImageIO or the fast TGA writer"); + System.out.println("depending on the file extension."); + System.exit(1); + } + + String filename = args[0]; + File file = new File(filename); + + GLCapabilities caps = new GLCapabilities(null); + caps.setDoubleBuffered(false); + + if (!GLDrawableFactory.getFactory(caps.getGLProfile()).canCreateGLPbuffer(null, caps.getGLProfile())) { + System.out.println("Demo requires pbuffer support"); + System.exit(1); + } + + // Use a pbuffer for rendering + final GLDrawableFactory factory = GLDrawableFactory.getFactory(caps.getGLProfile()); + final GLOffscreenAutoDrawable glad = factory.createOffscreenAutoDrawable(null, caps, null, 256, 256, null); + + final Gears gears = new Gears(); + gears.setDoRotation(false); + glad.addGLEventListener( gears ); + + // Fix the image size for now + // final int imageWidth = glad.getWidth() * 16; + // final int imageHeight = glad.getHeight() * 12; + final int imageWidth = glad.getWidth() * 2; + final int imageHeight = glad.getHeight() * 2; + + // Figure out the file format + TGAWriter tga = null; + BufferedImage img = null; + ByteBuffer buf = null; + + if (filename.endsWith(".tga")) { + tga = new TGAWriter(); + tga.open(file, + imageWidth, + imageHeight, + false); + buf = tga.getImageData(); + } else { + img = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_3BYTE_BGR); + buf = ByteBuffer.wrap(((DataBufferByte) img.getRaster().getDataBuffer()).getData()); + } + + // Initialize the tile rendering library + final TileRenderer2 renderer = new TileRenderer2(); + final TileRenderer.PMVMatrixCallback pmvMatrixCallback = new TileRenderer.PMVMatrixCallback() { + public void reshapePMVMatrix(GL _gl, int tileNum, int tileColumn, int tileRow, int tileX, int tileY, int tileWidth, int tileHeight, int imageWidth, int imageHeight) { + final GL2 gl = _gl.getGL2(); + gl.glMatrixMode( GL2.GL_PROJECTION ); + gl.glLoadIdentity(); + + /* compute projection parameters */ + float left, right, bottom, top; + if( imageHeight > imageWidth ) { + float a = (float)imageHeight / (float)imageWidth; + left = -1.0f; + right = 1.0f; + bottom = -a; + top = a; + } else { + float a = (float)imageWidth / (float)imageHeight; + left = -a; + right = a; + bottom = -1.0f; + top = 1.0f; + } + final float w = right - left; + final float h = top - bottom; + final float l = left + w * tileX / imageWidth; + final float r = l + w * tileWidth / imageWidth; + final float b = bottom + h * tileY / imageHeight; + final float t = b + h * tileHeight / imageHeight; + + final float _w = r - l; + final float _h = t - b; + System.err.println(">> [l "+left+", r "+right+", b "+bottom+", t "+top+"] "+w+"x"+h+" -> [l "+l+", r "+r+", b "+b+", t "+t+"] "+_w+"x"+_h); + gl.glFrustum(l, r, b, t, 5.0f, 60.0f); + + gl.glMatrixMode(GL2.GL_MODELVIEW); + } + }; + + renderer.attachAutoDrawable(glad, 0, pmvMatrixCallback); + renderer.setImageSize(imageWidth, imageHeight); + renderer.setImageBuffer(GL2.GL_BGR, GL.GL_UNSIGNED_BYTE, buf); + + while ( renderer.display() ); + + renderer.detachAutoDrawable(); + + glad.destroy(); + + // Close things up and/or write image using ImageIO + if (tga != null) { + tga.close(); + } else { + if (!ImageIO.write(img, IOUtil.getFileSuffix(file), file)) { + System.err.println("Error writing file using ImageIO (unsupported file format?)"); + } + } + } +} |