Am I painting to an offscreen buffer correctly?

Question

Hi all,
I am creating a simulation, and I want to paint the view for the simulation smoothly. Currently I have a thread that is looping around and calling repaint() every 50 ms. However, the animation is a little jerky and occasionally some parts of the view are visibly painted before others, so it looks odd (as a note, painting usually takes 30-40 ms, but occasionally spikes as high as 100 ms).
I am trying out painting to an offscreen buffer first, but I'm not sure if I'm doing it the right way. I am using a short tutorial I found.
I used to have a paint() method in my JComponent-extending view which used to look like:
paint(Graphics g){
    // do a whole bunch of painting, including cycling through hundreds of
   // images and painting them to g
}From what I could tell, I could keep this method intact, but instead of painting to the Graphics g that is passed in when repaint() is called, I could paint it to a BufferedImage, and then just paint that BufferedImage. I've posted the code below.
However, when I try this, the painting is much, much jerkier then before. Basically it paints one half of the screen, then the other half, alternating at about a 10 hertz rate, so it's not good at all.
Am I implementing the offscreen buffer pattern correctly? Would it not work in my case? Any suggestions? Thanks!
The new code I used:
     private BufferedImage offImg;
      public void paint(Graphics g){
           if (getSize().width <= 0 || getSize().height <= 0)
                return;
              Graphics2D g2 = createGraphics2D(g);
              draw(g2);
              g2.dispose();
              if (offImg != null && isShowing()) {
                g.drawImage(offImg, 0, 0, this);
      public Graphics2D createGraphics2D(Graphics g){
          Graphics2D g2 = null;
          if (offImg == null || offImg.getWidth() != getSize().width
                  || offImg.getHeight() != getSize().height) {
               offImg = (BufferedImage) createImage(getSize().width,
                       getSize().height);
          if (offImg != null) {
               g2 = offImg.createGraphics();
               g2.setBackground(getBackground());
          // .. set attributes ..
          g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                  RenderingHints.VALUE_ANTIALIAS_ON);
          // .. clear canvas ..
          g2.clearRect(0, 0, getSize().width, getSize().height);
          return g2;
     public void draw(Graphics g)
           // the exact same long complex code I originally had in the paint() method
       }

Answer 1

except that he is using paintComponent instead of paintThat's actually a key difference. The double buffering magic that swing does starts in the JComponent's paint() method. If you override the paint() method to do your own thing, then there's a chance that you've effectively nullified double buffering for that component. That's why custom painting code goes into the the paintComponent method.
Now, your combination of drawing to a BufferedImage and then drawing to the graphics context within the paintComponent method will+ be slower. The graphics context passed to
public void paintComponent(Graphics g) {
}will be to a VolatileImage 99.9% of the time. Which means you might as well directly use "g", since it's equivalent to drawing on a back image which happens to faster than BufferedImage. Drawing on an intermediate image within the paintComponent will only slow things down.
In the event that you're painting too much and the animation is too slow, then the suggestion is to do all your drawings in a seperate thread on a back image, and then have your paintComponent(Graphics g) method paint only that image.
public void paintComponent(Graphics g) {
    g.drawImage(theImage,0,0,null);
}You would also decrease the sleep time in the seperate thread to try to get all the drawing done on time. You can use a BufferedImage for the back image, or with slightly more code managing - use a VolatileImage.
Component#createVolatileImage(int width, int height);