Hello,
Does anyone know how to actually create one of those automatic images? I have searched through the archives but couldn’t find any specific examples. I am currently using Toolkit.createImage() . But how do I actually get the loaded image into my BufferedImage that I get from the createCompatibleImage method? I tried getting the Graphics2D from the BufferedImage and drawing the loaded image to it but it didn’t work(no errors just no Image).
Thanks,
Steve
I prefer to call those images “accelerated images” instead of “automatic”. The full term would be “images, which may be accelerated under the hood”.
Currently 2D may accelerate images returned
by the following methods:
You don’t need to copy the image returned by these methods to other images to ‘accelerate’ them, just use them, i.e. either render to them:
Image image = createImage(w, h);
Graphics g = image.getGraphics();
g.fillRect(0, 0, 100, 100);
// etc
or just copy them to the screen or other image.
I’m not sure why rendering an image to another image didn’t work for you, please provide more details. Which of the Toolkit.createImage did you use?
Hello,
Thanks for the info. I was getting rather confused on how to take advantage of hardware and somehow got it in my mind that by default all rendering would be in software. The archived posts I read kept talking about that createCompatibleImage method. So I should be okay by just using the toolkit?
following is the code I am using and still cannot draw to the buffered image can anyone see what I am doing wrong? (Although I don’t really need to do it anyway)
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.*;
public class test implements ImageObserver
{
private Image _image;
private int _intImageCount;
public void start()
{
Frame f = new Frame();
f.setIgnoreRepaint(true);
f.setUndecorated(true);
f.setBackground(Color.BLACK);
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().setFullScreenWindow(f);
f.createBufferStrategy(2);
BufferStrategy buffer = f.getBufferStrategy();
loadImage();
int frames = 0;
long lStartRenderingTime = System.currentTimeMillis();
while(frames < 2000)
{
Graphics2D graphics = (Graphics2D) buffer.getDrawGraphics();
clear(graphics);
AffineTransform at = new AffineTransform();
graphics.drawImage(_image,at,f);
buffer.show();
graphics.dispose();
frames++;
}
long lEndRenderingTime = System.currentTimeMillis();
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().setFullScreenWindow(null);
f.dispose();
System.out.println("Rendering Loop Time --> " + (lEndRenderingTime - lStartRenderingTime));
System.out.println("Frames --> " + frames);
System.out.println("FPS --> " + (1000 / ((lEndRenderingTime - lStartRenderingTime) / frames)) );
}
protected void clear(Graphics2D graphics)
{
graphics.setColor(Color.BLACK);
graphics.setClip(0,0,1024,768);
graphics.fillRect(0,0,1024,768);
}
public void loadImage()
{
Image image = Toolkit.getDefaultToolkit().createImage("c:\\corsairImages\\Corsair.png");
while(image.getHeight(null) == -1 && image.getWidth(null) == -1)
{
//Just Wait
}
//_image = image;
_image = createCompatibleImage(image);
_intImageCount++;
}
private Image createCompatibleImage(Image loadedImage)
{
GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
BufferedImage image = gc.createCompatibleImage(loadedImage.getWidth(null),loadedImage.getHeight(null),Transparency.BITMASK);
image.createGraphics().drawImage(loadedImage,new AffineTransform(),this);
return image;
}
public static void main(String args[])
{
test t = new test();
t.start();
}
public boolean imageUpdate(Image img,int infoflags,int x,int y,int width,int height)
{
int intResult = infoflags & ImageObserver.ALLBITS;
if(intResult == ImageObserver.ALLBITS)
System.out.println("Buffered Image Loaded");
else
System.out.println("image loading...........");
return true;
}
}
It looks like the problem is in the way you’re reading the image. Your code seem to assume that the image is loaded when the width and height of the image are not -1’s. That may not be true, so you’re basically rendering an empty (that is, transparent) image to the BufferedImage.
You actually should use ImageTracker class to make sure your image is fully read before using it.
Or, as a shortcut, some people use swing’s ImageIcon class:
ImageIcon icon = new ImageIcon(myImageFile); // this construcror makes sure the image is fully read
Image image = icon.getImage();
Also, you don’t actually need to copy the image you’ve read into another image in order to use it. It’d be automatically accelerated for you when you copy it to the screen/backbuffer at least two times.
Question in the same way:
Is it possible to know if an image is accelerated via a BufferedImage or Image? VolatileImage provides ImageCapabilities about that but what about other image types?
Thanks.
Hello,
Thanks again for the info. When I used ImageIcon then the above code worked fine.
,
Steve
TheAnalogKid: no, there is no wayto find out if an image is accelerated (BufferedImage, or Image).
The acceleration for the images other than Volatile is supposed to be hidden, or transparent to the user.
Thanks for your answer trembovetski!