How do I fix extremely slow rendering with buffered images?

Question

I've found random examples of people with this problem, but I can't seem to find any solutions in my googling. So I figured I'd go to the source. Basically, I am working on a simple platform game in java (an applet) as a surprise present for my girlfriend. The mechanics work fine, and are actually really fast, but the graphics are AWFUL. I wanted to capture some oldschool flavor, so I want to render several backgrounds scrolling in paralax (the closest background scrolls faster than far backgrounds). All I did was take a buffered image and create a graphics context for it. I pass that graphics context through several functions, drawing the background, the distant paralax, the player/entities, particles, and finally close paralax.
Only problem is it runs at like 5 fps (estimated, I havn't actually counted).
I KNOW this is a graphics thing, because I can make it run quite smoothly by commenting out the code to draw the background/paralax backgrounds... and that code is nothing more complicated than a graphics2d.drawImage
So obviously I am doing something wrong here... how do I speed this up?
Code for main class follows:
import javax.swing.JApplet;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.event.*;
import Entities.*;
import Worlds.*;
// run this applet in 640x480
public class Orkz extends JApplet implements Runnable, KeyListener
     double x_pos = 10;
     double y_pos = 400;
     int xRes=640;
     int yRes=480;
     boolean up_held;
     boolean down_held;
     boolean left_held;
     boolean right_held;
     boolean jump_held;
     Player player;
     World world;
     BufferedImage buffer;
     Graphics2D bufferG2D;
     int radius = 20;
     public void init()
          //xRes=(int) this.getSize().getWidth();
          //yRes=(int) this.getSize().getHeight();
        buffer=new BufferedImage(xRes, yRes, BufferedImage.TYPE_INT_RGB);
        bufferG2D=buffer.createGraphics();
          addKeyListener(this);
     public void start ()
            player=new Player(320, 240, xRes,yRes);
            world=new WorldOne(player, getCodeBase(), xRes, yRes);
            player.setWorld(world);
           // define a new thread
           Thread th = new Thread (this);
           // start this thread
           th.start ();
     public void keyPressed(KeyEvent e)
          //works fine
     }//end public void keypressed
     public void keyReleased(KeyEvent e)
          //this works fine
     public void keyTyped(KeyEvent e)
     public void paint( Graphics g )
           update( g );
    public void update(Graphics g)
         Graphics2D g2 = (Graphics2D)g;              
         world.render(bufferG2D);                
         g2.drawImage(buffer, null, null);
     public void run()
          // lower ThreadPriority
          Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
          long tm;
          long tm2;
          long tm3;
          long tmAhead=0;
          // run a long while (true) this means in our case "always"
          while (true)
               tm = System.currentTimeMillis();
               player.moveEntity();
              x_pos=player.getXPos();
              y_pos=player.getYPos();
              tm2 = System.currentTimeMillis();
                if ((tm2-tm)<20)
                 // repaint the applet
                 repaint();
                else
                     System.out.println("Skipped draw");
                tm3= System.currentTimeMillis();
                tmAhead=25-(tm3-tm);
                try
                    if (tmAhead>0) 
                     // Stop thread for 20 milliseconds
                      Thread.sleep (tmAhead);
                      tmAhead=0;
                    else
                         System.out.println("Behind");
                catch (InterruptedException ex)
                      System.out.println("Exception");
                // set ThreadPriority to maximum value
                Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
     public void stop() { }
     public void destroy() { }
}Here's the code for the first level
package Worlds;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.*;
import javax.swing.*;
import javax.imageio.*;
import java.awt.event.*;
import java.awt.*;
import java.awt.image.*;
import java.io.File;
import java.net.URL;
import java.awt.geom.AffineTransform;
import Entities.Player;
public class WorldOne implements World
     Player player;
     //Location of Applet
     URL codeBase;
     // Image Resources
     BufferedImage paralax1Image;
     BufferedImage paralax2Image;
     BufferedImage backgroundImage;
     // Graphics Elements     
     int xRes;
     int yRes;
     double paralaxScale1,paralaxScale2;
     double worldSize;
     int frameX=1;
     int frameY=1;
     public WorldOne(Player player, URL codeBase, int xRes, int yRes)
          this.player=player;
          this.codeBase=codeBase;
          this.xRes=xRes;
          this.yRes=yRes;
          worldSize=4000;
        String backgroundImagePath="worlds\\world1Graphics\\WorldOneBack.png";
        String paralax1ImagePath="worlds\\world1Graphics\\WorldOnePara1.png";
        String paralax2ImagePath="worlds\\world1Graphics\\WorldOnePara2.png";
        try
        URL url1 = new URL(codeBase, backgroundImagePath);
         URL url2 = new URL(codeBase, paralax1ImagePath);
         URL url3 = new URL(codeBase, paralax2ImagePath);
        backgroundImage = ImageIO.read(url1);
        paralax1Image  = ImageIO.read(url2);
        paralax2Image = ImageIO.read(url3);
        paralaxScale1=(paralax1Image.getWidth()-xRes)/worldSize;
        paralaxScale2=(paralax2Image.getWidth()-xRes)/worldSize;
        catch (Exception e)
             System.out.println("Failed to load Background Images in Scene");
             System.out.println("Background Image Path:"+backgroundImagePath);
             System.out.println("Background Image Path:"+paralax1ImagePath);
             System.out.println("Background Image Path:"+paralax2ImagePath);
     }//end constructor
     public double getWorldSize()
          double xPos=player.getXPos();
          return worldSize;
     public void setFramePos(int frameX, int frameY)
          this.frameX=frameX;
          this.frameY=frameY;
     public int getFrameXPos()
          return frameX;
     public int getFrameYPos()
          return frameY;
     public void paralax1Render(Graphics2D renderSpace)
          int scaledFrame=(int)(paralaxScale1*frameX);
          renderSpace.drawImage(paralax1Image,-scaledFrame,0,null); //Comment this to increase performance Massively
     public void paralax2Render(Graphics2D renderSpace)
          int scaledFrame=(int)(paralaxScale2*frameX);
          renderSpace.drawImage(paralax2Image,-scaledFrame,0,null); //Comment this to increase performance Massively
     public void backgroundRender(Graphics2D renderSpace)
          renderSpace.drawImage(backgroundImage,null,null); //Comment this to increase performance Massively
     public void entityRender(Graphics2D renderSpace)
          //System.out.println(frameX);
          double xPos=player.getXPos()-frameX+xRes/2;
         double yPos=player.getYPos();
         int radius=15;
         renderSpace.setColor (Color.blue);
        // paint a filled colored circle
         renderSpace.fillOval ((int)xPos - radius, (int)yPos - radius, 2 * radius, 2 * radius);
          renderSpace.setColor(Color.blue);
     public void particleRender(Graphics2D renderSpace)
          //NYI
     public void render(Graphics2D renderSpace)
          backgroundRender(renderSpace);
          paralax2Render(renderSpace);
          entityRender(renderSpace);
          paralax1Render(renderSpace);
}//end class WorldOneI can post more of the code if people need clarification. And to emphasize, if I take off the calls to display the background images (the 3 lines where you do this are noted), it works just fine, so this is purely a graphical slowdown, not anything else.
Edited by: CthulhuChild on Oct 27, 2008 10:04 PM

Answer 1

are the parallax images translucent by any chance? The most efficient way to draw images with transparent areas is to do something like this:
     public static BufferedImage optimizeImage(BufferedImage img)
          GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();                    
          GraphicsConfiguration gc = gd.getDefaultConfiguration();
          boolean istransparent = img.getColorModel().hasAlpha();
          BufferedImage img2 = gc.createCompatibleImage(img.getWidth(), img.getHeight(), istransparent ? Transparency.BITMASK : Transparency.OPAQUE);
          Graphics2D g = img2.createGraphics();
          g.drawImage(img, 0, 0, null);
          g.dispose();
          return img2;
     }I copied this from a util class I have and I had to modify it a little, I hope I didn't break anything.
This piece of code does a number of things:
- it allows the images to be hardware accelerated
- the returned image is 100% compatible with the display, regardless of what the input image is
- BITMASK transparent images are an incredible amount faster than translucent images
BITMASK means that a pixel is either fully transparent or it is fully opaque; there is no alpha blending being performed. Alpha blending in software rendering mode is very slow, so this may be the bottleneck that is bothering you.
If you require your parallax images to be translucent then I wouldn't know how to get it to draw quicker in an applet, other than trying out java 6 update 10 to see if it fixes things.