[SOLVED]OpenGL Context

[Vladiedoo]

Hi,
I recently added the screenshot feature to my LWJGL game but noticed that there was a slight delay when taking a screenshot. To fix the issue I created a second thread that will take care of screenshots to hopefully remove the tiny delay but I get the following error ->

1   2   3   4   5

Exception in thread "Thread-1" java.lang.RuntimeException: No OpenGL context found in the current thread.    at org.lwjgl.opengl.GLContext.getCapabilities(GLContext.java:124)    at org.lwjgl.opengl.GL11.glReadBuffer(GL11.java:2463)    at com.Vlad.AuFait.AuFait.screenShot(AuFait.java:785)    at com.Vlad.AuFait.ScreenShot.run(ScreenShot.java:30)

The only thing I know about OpenGL context is that "Display.create()" creates it.
Line 30 calls this function.

This function works. I am getting the no context error when my screenshot thread tries to call it.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27

// Code from LWJGL.org    public void screenShot() {       GL11.glReadBuffer(GL11.GL_FRONT);       int bpp = 4; // Assuming a 32-bit display with a byte each for red, green, blue, and alpha.       ByteBuffer buffer = BufferUtils.createByteBuffer(DISPLAY_CURRENT_WIDTH * DISPLAY_CURRENT_HEIGHT * bpp);       GL11.glReadPixels(0, 0, DISPLAY_CURRENT_WIDTH, DISPLAY_CURRENT_HEIGHT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, buffer);       File file = new File("Screenshot.PNG"); // The file to save to.       String format = "PNG"; // Example: "PNG" or "JPG"       BufferedImage image = new BufferedImage(DISPLAY_CURRENT_WIDTH, DISPLAY_CURRENT_HEIGHT, BufferedImage.TYPE_INT_RGB);             for (int x = 0; x < DISPLAY_CURRENT_WIDTH; x++) {          for (int y = 0; y < DISPLAY_CURRENT_HEIGHT; y++) {             int i = (x + (DISPLAY_CURRENT_WIDTH * y)) * bpp;             int r = buffer.get(i) & 0xFF;             int g = buffer.get(i + 1) & 0xFF;             int b = buffer.get(i + 2) & 0xFF;             image.setRGB(x, DISPLAY_CURRENT_HEIGHT - (y + 1), (0xFF << 24) | (r << 16) | (g << 8) | b);          }       }             try {          ImageIO.write(image, format, file);       } catch (IOException e) {          e.printStackTrace();       }    }

My question: How do I share the OpenGL context? What should I pass onto my second thread?

Note: Yeah GL11 is deprecated, I'll work on using more updated OpenGL.

Thanks for your time.

[HeroesGraveDev]

As far as I know, there can only be one OpenGL context per thread if there is any at all.

You would have to call Display.create() in the new thread to get another OpenGL context, but that obviously won't work as it has to be the same context for the screenshot to work.

I have no idea if you can achieve this. I don't believe it's even possible.

What you could do to reduce the lag is start a new Thread once you've read the data from the screen. Then you can convert the data in the buffer to a BufferedImage and write that in the separate Thread.
This way, the only lag caused will be from reading the screen to a buffer.

EDIT: GL11 is deprecated?? Since when? Any why? And what should I be using?  

By the way, is there a difference between the BACK buffer and the FRONT buffer when taking screenshots?

[Vladiedoo]

What you could do to reduce the lag is start a new Thread once you've read the data from the screen. Then you can convert the data in the buffer to a BufferedImage and write that in the separate Thread.
This way, the only lag caused will be from reading the screen to a buffer.

EDIT: GL11 is deprecated?? Since when? Any why? And what should I be using?  

Thanks I'll try that, oh and about the GL11 I believe I remember reading it in a post here, I am not sure what is better, I have a lot to learn.

EDIT: I found the post.
http://www.java-gaming.org/topics/lwjgl-struggling-with-vbo-s/27926/view.html

"Did you import LWJGL and why are you using OGL3? I think you could maybe do it with GL11 wthout much problems." (masteryoom)

"Why use OpenGL at all? He could probably use something even more deprecated.

+1 to OGL3." (theagentd)

EDIT 2: I am not sure on the exact difference between BACK and FRONT buffer either, sorry.

Games published by our own members! Check 'em out!

[davedes]

1. The lag is likely because you are using setRGB which is very slow. For modifying pixels, you should grab the pixel array from the DataBuffer of a BufferedImage and change it directly.

2. The lag may also be due to ImageIO output, which can easily be put into a separate thread as it does not use any OpenGL.

3. LWJGL includes some features for multiple contexts and calling GL from different threads, but it would be overkill for a simple screenshot function.

4. GL 1.1 is not deprecated, although many "fixed function" methods from 1.1 (e.g. glVertex2f) are deprecated in favour of shaders and the programmable pipeline (GL 3+). Things like glReadPixels are not deprecated.

[Vladiedoo]

Awesome, thanks for all the information.

I actually do not need to modify pixels though, I should have mentioned my purpose behind this is so that I can take the screenshot and use it as a wall texture (it serves game-play functionality).

1   2

// This will then become binded to a quad. screenShotTexture = TextureLoader.getTexture("PNG", ResourceLoader.getResourceAsStream("Screenshot.PNG"));

I'll make sure to give my second thread the ImageIO output.

Thanks again.

[davedes]

Why do you need to output the image to a file? No wonder you are getting lag, if you are saving the file, and then loading it back...

Just upload the pixels to a texture.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15

Image outImage; ... init ... {       outImage = new Image(SCREEN_WIDTH, SCREEN_HEIGHT); } public void screenShot() {       GL11.glReadBuffer(GL11.GL_FRONT);           ByteBuffer buffer = BufferUtils.createByteBuffer(SCREEN_WIDTH * SCREEN_HEIGHT * 4);       GL11.glReadPixels(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, buffer);       //upload data to our image       outImage.bind();       GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, buffer); }

[Vladiedoo]

That is much faster, thank you so much !

Yeah I thought it was a bit silly to do that whole cycle, I didn't know a way around it.