java volatile img

Java 2D
#1

hey guys. just getting started with java.
i have got a question: i coded a source-loader class and a sprite class using simple images (Image x).
would i achieve to increase fps by using volatile images instead of simple images even if the back-buffer is of type volatile?

my current game speed (100 sprites) @ 1280x1024 pix: 1003 fps

thank you

import java.awt.Color;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.ImageObserver;
import java.awt.image.VolatileImage;
import java.util.HashMap;
import java.util.Map;

public class FullScreen
{
    final GraphicsEnvironment gE = GraphicsEnvironment.getLocalGraphicsEnvironment();
    final GraphicsDevice gDevice = gE.getScreenDevices()[0];
    final GraphicsConfiguration gc = gDevice.getDefaultConfiguration();
    final Dimension  screen = Toolkit.getDefaultToolkit().getScreenSize();
       
    private Frame display = new Frame(gc);
    private Map<RenderingHints.Key, Object> config = new HashMap<RenderingHints.Key, Object>();
    private Main main;
       
    public FullScreen()
    {    
        display = new Frame(gc);
        display.setUndecorated(true);
        display.setIgnoreRepaint(true);
        display.setResizable(false);
        display.enableInputMethods(false);
        gDevice.setFullScreenWindow(display);
        
        main = new Main(display);
           
        config.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
        config.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
        config.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
        config.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
        config.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
        config.put(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
        config.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
        config.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
        config.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
           
        display.addKeyListener(new KeyListener()
                {

            public void keyPressed(KeyEvent e) 
            {
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE) 
                {
                    display.setVisible(false);
                    display.dispose();
                    System.exit(0);
        			}
            }

            public void keyReleased(KeyEvent arg0) {}

			public void keyTyped(KeyEvent arg0) {}
              
                });
           
        int fps_counter = 0;
        long t_start = System.currentTimeMillis();
        long t_current = 0, fps = 0;
           
        DisplayMode dm = new DisplayMode(screen.width, screen.height, 32, DisplayMode.REFRESH_RATE_UNKNOWN);
        gDevice.setDisplayMode(dm);
        Graphics2D buffered = (Graphics2D) display.getGraphics();
        buffered.setRenderingHints(config);
           
        ImageObserver io = display;
        VolatileImage img = display.createVolatileImage(screen.width, screen.height);
        Graphics2D g = (Graphics2D) img.createGraphics();
        g.setRenderingHints(config);
           
        while(true)
        {
            g.clearRect(0, 0, screen.width, screen.height);

            if(t_current > t_start + 1000)
            {
                t_start = System.currentTimeMillis();
                fps = fps_counter;
                fps_counter = 0;
            }
               
            ++ fps_counter;
            
            main.paint(g);
            
            g.setColor(Color.RED);
            g.drawString("fps: " + fps, 10, 20);
               
            buffered.drawImage(img, 0, 0, io);
            t_current = System.currentTimeMillis();
        }
    }
       
    public static void main(String[] args)
    {
        new FullScreen();
    }
}
#2

i found this:

VolatileImage: This image type was created in JDK 1.4 as a means of creating and managing accelerated image memory. One of the problems with hardware acceleration for images is that, on some platforms, accelerated memory can be deleted out from under you at any time. This is obviously not what you want for your typical image data. To work around that, the VolatileImage API was created to provide a notification mechanism so that you know when an image must be re-rendered due to data loss. VolatileImage objects are not loaded from image data, but are just created as empty pixel buffers (much as the initial BufferedImage objects were (see above)); to load image data into a VolatileImage, applications must load the image data through some non-Volatile means, get the Graphics object for the VolatileImage, and then copy the data into the Graphics

#3

Rendering BufferedImages to a VolatileImage is also accalerated if possible, so replacing BufferedImages with VIs won’t speed your stuff up.
Its quite simply: Rendering to an VI is accaletared, but rendering from an image is accalerated with both, BufferedImages and VolatileImages.

lg Clemens