Super Large 9600 x 1080 GLGraphicsOffScreen object

datadream..

Super Large 9600 x 1080 GLGraphicsOffScreen object

in Contributed Library Questions • 2 years ago

Here is a rundown of my current project:

5 large 1080p displays hooked up to a Radeon 6990. We will attempt to use an Eyefinity 5x1 configuration (if we can ever figure out how to properly set it up) with a bit of a twist. Since we want the displays to be side by side in landscape mode and run along a wall in a VERY wide setup (around 20+ feet), and since Eyefinity 5x1 mode only supports portrait mode (5400 x 1920), I intend to draw to a raster off screen using GLGraphics which will be 9600 x 1080, and then split that into 5 pieces, rotate them 90 degrees, and then place them side by side. The effect is similar to this:

This is a 960 x 108 (1/10th the width and height, ie: 1/100th the final intended size) drawn to a GLGraphicsOffScreen object. When I actually apply it to the GLGraphics context being displayed, which is only 540 x 192, it looks like this:

When all of the displays are rotated 90 degrees into landscape mode, it should all look perfect.

Still with me? Great.

This works as expected at this resolution. However, I am increasing to production size in order to build a jar and send it out to be tested on the production machine with the displays attached. The workstation arrived today featuring an i7 950, 6 gigs of ram, the Radeon 6990, and Windows 7 pro 64-bit. It's a beast. However, I won't be back to work with the hardware myself for another 2 weeks, so I am stuck developing precursor test jars on my laptop (a 1.5 year old thinkpad... not terrible, but no beast).

In preparation for this, I increased my size() parameter to 5400 x 1920, and my off screen size to 9600 x 1080. When I ran my application, I received this error:

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

OpenGL error 1280 at top endDraw(): invalid enumerant

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

OpenGL error 1282 at render_triangles in: invalid operation

OpenGL error 1286 at non-binding 6: invalid framebuffer operation

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

Frame buffer is incomplete (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)

... and then it just repeats the last line ad infinitum while the application runs.

Having searched the forum for this type of error I don't find a whole lot of results. So I figure one of two things: (1) my relatively puny graphics acceleration chip in my laptop just can't handle the awesomeness, or (2) this is some kind of constraint in either GLGraphics or OpenGL itself... I really don't know.

ANY insight into what these errors mean, or limitation in the software, or even the hardware I'm using, would be MUCH appreciated. Do you think I can build the jar and send it off and it may work on the awesome 6990 hardware, and it's just a limitation of my laptop? Or am I boned thinking that I can execute this entirely?

Included are two snippets of code from my project thus far; NevadaMain.java and NevadaApplet.java. NevadaMain is simply the frame to house my PApplet instance, and NevadaApplet extends PApplet (sorry PDE users, but I only develop in Eclipse now). I have also included the props file which is being read to determine my resolution settings.

NEVADAMAIN.java:

package com.datadreamer.nevada;
import java.applet.Applet;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import javax.swing.JFrame;
@SuppressWarnings("serial")
public class NevadaMain extends JFrame {
private Applet app;
public NevadaMain() {
super("Nevada Discovery Museum");
Properties props = loadProperties("data/main.props");
int w = Integer.valueOf(props.getProperty("displayWidth"));
int h = Integer.valueOf(props.getProperty("displayHeight"));
setResizable(false);
setBounds(0, 0, w, h);
setUndecorated(true);
setVisible(true);
app = new NevadaApplet(w, h, props);
add(app);
addWindowListener(new WindowAdapter() {
public void windowOpened(WindowEvent e) {
app.requestFocus();
}
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
app.init();
}
public Properties loadProperties(String file) {
Properties newprops = new Properties();
try {
newprops = new Properties();
newprops.load(new FileInputStream(new File(file)));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return newprops;
}
public static void main(String[] args) {
new NevadaMain();
}
}

NEVADAAPPLET.java:

package com.datadreamer.nevada;
import java.util.Properties;
import processing.core.PApplet;
import processing.core.PImage;
import codeanticode.glgraphics.GLConstants;
import codeanticode.glgraphics.GLGraphicsOffScreen;
import codeanticode.glgraphics.GLTexture;
@SuppressWarnings("serial")
public class NevadaApplet extends PApplet {
private final int w, h;
// private final Properties props;
private GLGraphicsOffScreen canvas;
private final int offscreenWidth;
private final int offscreenHeight;
private PImage cloudTest;
public NevadaApplet(int w, int h, Properties props) {
// this.props = props;
this.w = w;
this.h = h;
offscreenWidth = Integer.valueOf(props.getProperty("offscreenWidth"));
offscreenHeight = Integer.valueOf(props.getProperty("offscreenHeight"));
}
public void setup() {
size(w, h, GLConstants.GLGRAPHICS);
frameRate(60);
canvas = new GLGraphicsOffScreen(this, offscreenWidth, offscreenHeight);
cloudTest = loadImage("cloudTest8192.png");
}
public void draw() {
background(255, 0, 0);
canvas.beginDraw();
canvas.image(cloudTest, 0, 0, offscreenWidth, offscreenHeight);
canvas.endDraw();
GLTexture fullScreen = canvas.getTexture();
translate(0, height);
rotate(radians(-90));
image(fullScreen, 0, 0, offscreenWidth, width / 5);
image(fullScreen, -(offscreenWidth / 5), (width / 5), offscreenWidth,
width / 5);
image(fullScreen, -(offscreenWidth / 5) * 2, (width / 5) * 2,
offscreenWidth, width / 5);
image(fullScreen, -(offscreenWidth / 5) * 3, (width / 5) * 3,
offscreenWidth, width / 5);
image(fullScreen, -(offscreenWidth / 5) * 4, (width / 5) * 4,
offscreenWidth, width / 5);
}
}

MAIN.props

# on screen display resolution
displayWidth = 5400
displayHeight = 1920
#displayWidth = 540
#displayHeight = 192
# off screen canvas being drawn to
offscreenWidth = 9600
offscreenHeight = 1080
#offscreenWidth = 960
#offscreenHeight = 108

Toggle the values above to render the 1/100th version without issue, or attempt to strangle your hardware/software with the full version. The image "cloudTest8192.png" is unfortunately quite large (8192 x 922, as that's the widest my laptop's graphics card accepts) and I should probably refrain from uploading it, but I just grabbed a super giant photo of clouds from google images in order to test this.

Also, if you figure out a solution, I will buy you a beer.

Replies(9)

andres

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

One issue is probably the very large resolution you are using for your offscreen surface. Most video cards have 8192 as the maximum supported resolution for OpenGL textures, you can check this by running the following code:

int temp[] = {0};
gl.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, temp, 0);
println(temp[0]);

GLGraphicsOffscreen internally creates a set of OpenGL textures to use as color buffers, so this maximum texture size applies to offscreen surfaces as well.

datadream..

Re: Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

Thanks for the quick response, Andres. Hope all is well in your hemisphere.

Indeed that was it. When I dropped the GLGraphicsOffScreen object to 8192 x 922, it worked fine and displayed on my screen. I was hoping to not have to upscale anything to fit the resolution demands of this project, so I'll have to do some digging into the Radeon 6990 hardware or maybe find another solution to creating this imagery. I owe you a beer.

toxmeister

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

If you still have a chance to switch the gfx card, there're also options which support texture sizes upto 16384 pixels (e.g. even the ATI HD6750M in the beefed up MacBook Pro does)...

http://postspectacular.com | http://toxiclibs.org

toxmeister

Re: Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

The other alternative is to use 2 offscreen buffers (8192 wide + 1408 wide) and split rendering. Gonna be problematic though if you're using 3D...

http://postspectacular.com | http://toxiclibs.org

datadream..

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

Thanks for the feedback, Karsten. I'm really hoping that the Radeon 6990 supports larger textures (I haven't tried it yet, as my client back in LA has been banging his head against the wall just trying to get the Eyefinity 5x1 working). And yeah, we are planning on doing some 3D stuff, at least with text elements emerging from the clouds. This is one more reason why I wanted to do one large opengl context instead of simply using extended desktop with 5 displays, and then 5 separate opengl windows (headache). I won't be able to get my hands on the hardware and test stuff out myself until the 21st or 22nd, so I don't consider this thread dead.

datadream..

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

Just an update, I received this photo from my client in LA today:

It's running the code above with a couple slight modifications: (1) the GLGraphicsOffscreen object was reduced to 8192 x 922, and (2) the size is being compensated to scale the texture back up to be 9600 x 1080.

This is currently running not with Eyefinity 5x1 but simply using extended desktop. I will have to export another build this weekend with the code doing some more CPU intensive stuff and see what frame rate it's getting. Is it a performance hit to span a single opengl context across extended desktop displays on a single GPU? I have done this with multiple video cards and notice a massive frame rate drop, but I have not tried it from a single video card. If there is no performance drop, then we can probably proceed with the project just like this (and hopefully once I find out the max texture size for the Radeon 6990, increase the GLGraphicsOffscreen as well as the photos to the full 9600x1080).

Things are looking up.

andres

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

How are you planning to cover the extended desktops? Using a single GLTextureWindow object? If that's the case, you shouldn't experience any significant performance drop (there is a small penalty involved in the OpenGL context switching, but shouldn't be more than a few fps).

datadream..

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

I'm just creating a super large frame (5400 x 1920) which apparently is spanning all of the displays in extended desktop mode. I had my contact person attempt to run a new build today, and the video card does support 16384 sized textures, which is good news. However he was unable to see the onscreen text for the frame rate output, which seems really strange.

On a sour note, we have to return the computer because the video card that was included is producing green lines across one of the displays, and after consulting with some AMD people they confirmed that it is a known issue and the video card needs to be replaced. I'm hoping that after we get a new card we will be able to get the Eyefinity 5x1 working properly.

Andres: have you ever tried video of this dimensions using GSVideo? The people I'm working with seem eager to attempt it, but I'm afraid it's just too massive to be practical, and we'd be better off doing a time lapse of still images.

andres

Re: Super Large 9600 x 1080 GLGraphicsOffScreen object

2 years ago

No, I never tried such large resolutions with GLGraphics (but you just mentioned GSVideo, are you planning to include video playback as well?). The largest rendering dimensions I have ever used were 4096x4096, and this was only to generate a single high-res static image.

Maybe some back-of-the-envelope numbers could help. A resolution of 9600x1080 represents a total of ~10Mpixels/frame, and if you want to have a framerate of 30fps, then the video card should be able to push to the screen at least 300Mpixels/sec. If you are sampling from a 8192x922 texture, this represents a texel rate of 225Mtexels/sec. You can probably find the max. theoretical fill rates of your video card somewhere on the net.

Top Reply