Hi I'm trying to convert an image made in processing into a bufferImage for use in openGL as a texture, however, when I try to copy the pixels from the PGraphics object to the bufferedImage, I just get a blank result.

Has anyone managed to do this properly?

Quote:

I had a look at that thread prior to posting, however it only deals with loading an image file. I want to be able to use an image that I've just made.

It would be possible to just save the image out and load it that way, but it seems counter intuitive to me.

I've got no problem with the syntax involved with loading the texture, its converting the PImage to an BufferedImage that's vexing me.

Thanks for the response though.

Just tried it, and no it didn't

I also had a crack at adapting julapy's code on the thread moka linked to, but while it does actually produce something, the result is weird and skewed.

Also, making BufferedImages into Textures seems to be really slow somehow.

What's weird is if I change the call to TextureIO.newTexture(...) to load the texture with a file, its pretty much instant, but if I want it to load the Buffered one, it takes ages.

You'd have thought it would be the other way round.

I'm trying to make this all run independent of processing's OGL, as per http://processing.org/discourse/yabb_beta/YaBB.cgi?board=OpenGL;action=display;num=1209764312
I'm trying to make a VJ app and I'm trying to avoid the output stopping when an image or whatever is loaded.

Maybe I'm going about this the wrong way.

Nope, still doesn't want to work.

I found this forum post on it; http://forum.java.sun.com/thread.jspa?threadID=736202&messageID=4229597

but the solution uses Swing and i still don't understand it.

It looks like this is just beyond my understanding. I guess I'll just have to stick to processing's openGL and run all other computations in different Java threads.

Interesting, although the example I linked to above describes the same thing happening, but not being able to read it from memory.

I want to do this on the fly, so saving then loading from disk will be problematic. All I'm doing after the prepareText function is (attempting to) load the buffered image to a texture.

tex=TextureIO.newTexture(bi,false); //second argument is whether to generate mipmaps

If I use this command in its load file form;
tex=TextureIO.newTexture(new File("C:/foo.png"),false);

it works fine, so either the newTexture command is broken in JOGL or the image is somehow lost by the memory.

It doesn't make much sense.

Cheers
Martin

the thread I posted does not only deal with loading a texture. look at the end. There is an example of how to create a texture from a PImage object.

O M G

Sorry, I changed the boolean value for generate mipmaps to true instead, and it works.

I'm sorry for taking up so much time!

I now open the floor to insults and abuse.

Cheers guys

Well, for those that are interested, here's the final code;

I've tested this method, and my original method of copying the pixel array, and this one works out a good 30ms faster on my computer.

Code:

BufferedImage prepareText(String txt, PFont f){
  //the idea with this is to draw Text to an offscreen buffer, then load that as an image for use as a texture
  textFont(f);
  int w = int(textWidth(txt)+50);
  PGraphics pg;
  if(w<256){
    w=256;
  }
  pg = createGraphics(w,w,JAVA2D);
  pg.beginDraw();
  pg.background(0,0);
  pg.fill(255);
  pg.textFont(f);
  pg.textAlign(CENTER);
  pg.text(txt,w*0.5,w*0.5-(textDescent()*0.5));
  pg.endDraw();
  BufferedImage img = new BufferedImage(w, w, BufferedImage.TYPE_INT_ARGB_PRE  );
  Graphics2D g2d = img.createGraphics();
  g2d.drawImage((java.awt.Image)pg.image, 0, 0, w, w, this);
  g2d.finalize();
  g2d.dispose();

  return img;
}
 

You could extend this function to output a GL.Texture quite easily;

Code:

Texture prepareText(String txt, PFont f){
  //the idea with this is to draw Text to an offscreen buffer, then load that as an image for use as a texture
  textFont(f);
  int w = int(textWidth(txt)+50);
  PGraphics pg;
  if(w<256){
    w=256;
  }
  pg = createGraphics(w,w,JAVA2D);
  pg.beginDraw();
  pg.background(0,0);
  pg.fill(255);
  pg.textFont(f);
  pg.textAlign(CENTER);
  pg.text(txt,w*0.5,w*0.5-(textDescent()*0.5));
  pg.endDraw();
  BufferedImage img = new BufferedImage(w, w, BufferedImage.TYPE_INT_ARGB_PRE  );
  Graphics2D g2d = img.createGraphics();
  g2d.drawImage((java.awt.Image)pg.image, 0, 0, w, w, this);
  g2d.finalize();
  g2d.dispose();
  
  Texture tx = TextureIO.newTexture(img  ,true); 

  return tx;
}
 

Although I think its considered good practice to wrap any calls to TextureIO.newTexture in try catch braces, that might just be for loading from a file.

From what I've been reading as I've tried to solve this problem;

Once you have a GL texture made, you should edit it using the Texture.updateSubImage method, as its much faster and avoids unnecessary cycles.

BufferedImages have lots of different modes, I've picked the one that seems to work fastest.


The question is now, is it worth it? When I've got some time, I'll see if just doing this purely in processing's API is faster/slower.


Thanks for all the help

Martin