I’ve been struggling to get offscreen rendering to work with PBuffers for weeks under Windows, and finally I’ve given up. Really what I wanted was a way to render an image using OpenGL in a server environment where nothing was ever sent to the screen.
I finally got PBuffers working about a week ago, but it involved some ugly workarounds and they were very flaky. The program worked on some machines, but mostly I got the dang wglChoosePixelFormatARB exception. Also, the I never trusted the 0,0 window trick to provide an “onscreen” context for the PBuffer.
From reading other posts, I’m not the only one who has wanted to do something like this or has had problems, so I want to post my solution. It isn’t perfect or pretty, but it works on every windows machine I’ve tested.
Basically what I did was cut and pasted most of the JPanel code to make a component that just renders to an image. I don’t take any credit for this, because all I really did was take what I needed from the JOGL source:
import net.java.games.jogl.impl.*;
import net.java.games.jogl.*;
import java.awt.*;
import java.awt.image.*;
public class OffscreenPanel extends Component implements GLDrawable {
private GLDrawableHelper drawableHelper = new GLDrawableHelper();
private GLContext context;
private BufferedImage offscreenImage;
private int awtFormat;
private int glFormat;
private int glType;
private int glComps;
private DataBufferByte dbByte;
private DataBufferInt dbInt;
// For saving/restoring of OpenGL state during ReadPixels
private int[] swapbytes = new int[1];
private int[] lsbfirst = new int[1];
private int[] rowlength = new int[1];
private int[] skiprows = new int[1];
private int[] skippixels = new int[1];
private int[] alignment = new int[1];
private final int fx = 0;
private final int fy = 0;
OffscreenPanel(GLCapabilities capabilities, GLCapabilitiesChooser chooser, int width, int height) {
context = GLContextFactory.getFactory().createGLContext(null, capabilities, chooser, null);
context.resizeOffscreenContext(width, height);
resizeContext(width, height);
}
public void resizeContext(int w, int h) {
final int fwidth = w;
final int fheight = h;
context.invokeGL(new Runnable() {
public void run() {
getGL().glViewport(fx, fy, fwidth, fheight);
drawableHelper.reshape(OffscreenPanel.this, fx, fy, fwidth, fheight);
if (offscreenImage != null &&
(offscreenImage.getWidth() != context.getOffscreenContextWidth() ||
offscreenImage.getHeight() != context.getOffscreenContextHeight())) {
offscreenImage.flush();
offscreenImage = null;
}
}
}, true, initAction);
}
public void display() {
context.invokeGL(displayAction, false, initAction);
}
public BufferedImage getSnapshot () {
return offscreenImage;
}
public void addGLEventListener(GLEventListener listener) {
drawableHelper.addGLEventListener(listener);
}
public void removeGLEventListener(GLEventListener listener) {
drawableHelper.removeGLEventListener(listener);
}
public GL getGL() {
return context.getGL();
}
public void setGL(GL gl) {
context.setGL(gl);
}
public GLU getGLU() {
return context.getGLU();
}
public void setGLU(GLU glu) {
context.setGLU(glu);
}
public void setRenderingThread(Thread currentThreadOrNull) throws GLException {
throw new GLException("Not supported");
}
public Thread getRenderingThread() {
return context.getRenderingThread();
}
public void setNoAutoRedrawMode(boolean noAutoRedraws) {
}
public boolean getNoAutoRedrawMode() {
return false;
}
public boolean canCreateOffscreenDrawable() {
return false;
}
public GLPbuffer createOffscreenDrawable(GLCapabilities capabilities,
int initialWidth,
int initialHeight) {
throw new GLException("Not supported");
}
GLContext getContext() {
return context;
}
//----------------------------------------------------------------------
// Internals only below this point
//
class InitAction implements Runnable {
public void run() {
drawableHelper.init(OffscreenPanel.this);
}
}
private InitAction initAction = new InitAction();
class DisplayAction implements Runnable {
public void run() {
drawableHelper.display(OffscreenPanel.this);
// Must now copy pixels from offscreen context into surface
if (offscreenImage == null) {
int awtFormat = context.getOffscreenContextBufferedImageType();
offscreenImage = new BufferedImage(context.getOffscreenContextWidth(), context.getOffscreenContextHeight(), awtFormat);
switch (awtFormat) {
case BufferedImage.TYPE_3BYTE_BGR:
glFormat = GL.GL_BGR;
glType = GL.GL_UNSIGNED_BYTE;
glComps = 3;
dbByte = (DataBufferByte) offscreenImage.getRaster().getDataBuffer();
break;
case BufferedImage.TYPE_INT_RGB:
glFormat = GL.GL_BGRA;
glType = GL.GL_UNSIGNED_BYTE;
glComps = 4;
dbInt = (DataBufferInt) offscreenImage.getRaster().getDataBuffer();
break;
case BufferedImage.TYPE_INT_ARGB:
glFormat = GL.GL_BGRA;
glType = context.getOffscreenContextPixelDataType();
glComps = 4;
dbInt = (DataBufferInt) offscreenImage.getRaster().getDataBuffer();
break;
default:
throw new GLException("Unsupported offscreen image type " + awtFormat);
}
}
GL gl = getGL();
// Save current modes
gl.glGetIntegerv(GL.GL_PACK_SWAP_BYTES, swapbytes);
gl.glGetIntegerv(GL.GL_PACK_LSB_FIRST, lsbfirst);
gl.glGetIntegerv(GL.GL_PACK_ROW_LENGTH, rowlength);
gl.glGetIntegerv(GL.GL_PACK_SKIP_ROWS, skiprows);
gl.glGetIntegerv(GL.GL_PACK_SKIP_PIXELS, skippixels);
gl.glGetIntegerv(GL.GL_PACK_ALIGNMENT, alignment);
gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, GL.GL_FALSE);
gl.glPixelStorei(GL.GL_PACK_LSB_FIRST, GL.GL_TRUE);
gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, offscreenImage.getWidth());
gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0);
gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0);
gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1);
// Actually read the pixels.
gl.glReadBuffer(context.getOffscreenContextReadBuffer());
if (dbByte != null) {
gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbByte.getData());
} else if (dbInt != null) {
gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbInt.getData());
}
// Restore saved modes.
gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, swapbytes[0]);
gl.glPixelStorei(GL.GL_PACK_LSB_FIRST, lsbfirst[0]);
gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, rowlength[0]);
gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, skiprows[0]);
gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, skippixels[0]);
gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, alignment[0]);
gl.glFlush();
gl.glFinish();
}
}
private DisplayAction displayAction = new DisplayAction();
}
I have to reply to my own post, because it got to long. Continued below…