Advanced Graphics Java

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
/*
 * SmoothMoves.java
 *
 * Created on May 2, 2007, 4:49 PM
 *
 * Copyright (c) 2007, Sun Microsystems, Inc
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the TimingFramework project nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/**
 * 
 * @author Chet
 */
public class SmoothMoves extends JComponent implements ActionListener, KeyListener {
  /** image holds the graphics we render for each animating object */
  BufferedImage image = null;
  static int imageW = 100;
  static int imageH = 150;
  /** Location of fading animation */
  int fadeX = 50;
  int fadeY = 50;
  /** X values that moving animation will move between */
  static int moveMinX = 150;
  static int moveMaxX = 350;
  /** Current x/y location of moving animation */
  int moveX = moveMinX;
  int moveY = 50;
  /** Current opacity of fading animation */
  float opacity = 0.0f;
  /** Toggles for various demo options (key to toggle in parentheses) */
  boolean useImage = false; // (i) image instead of rectangle
  boolean useAA = false; // (a) anti-aliased edges (rectangle only)
  boolean motionBlur = false; // (b) ghost images behind moving animation
  boolean alterColor = false; // (c) light-gray instead of black rectangle
  boolean linear = true; // (l) linear vs. non-linear motion
  /** Used for motion blur rendering; holds information for ghost trail */
  int blurSize = 5;
  int prevMoveX[];
  int prevMoveY[];
  float trailOpacity[];
  /** Basic Timer animation info */
  final static int CYCLE_TIME = 2000; // One cycle takes 2 seconds
  int currentResolution = 50; // current Timer resolution
  Timer timer = null; // animation Timer
  long cycleStart; // track start time for each cycle
  /** Creates a new instance of SmoothAnimation */
  public SmoothMoves() {
    // createAnimationImage();
    cycleStart = System.nanoTime() / 1000000;
    startTimer(currentResolution);
  }
  /**
   * Create the image that will be animated. This image may be an actual image
   * (duke.gif), or some graphics (a variation on a black filled rectangle) that
   * are rendered into an image. The contents of this image are dependent upon
   * the runtime toggles that have been set when this method is called.
   */
  void createAnimationImage() {
    GraphicsConfiguration gc = getGraphicsConfiguration();
    image = gc.createCompatibleImage(imageW, imageH, Transparency.TRANSLUCENT);
    Graphics2D gImg = image.createGraphics();
    if (useImage) {
      try {
        URL url = getClass().getResource("duke.gif");
        Image originalImage = ImageIO.read(url);
        gImg.drawImage(originalImage, 0, 0, imageW, imageH, null);
      } catch (Exception e) {
      }
    } else {
      // use graphics
      Color graphicsColor;
      if (alterColor) {
        graphicsColor = Color.LIGHT_GRAY;
      } else {
        graphicsColor = Color.BLACK;
      }
      gImg.setColor(graphicsColor);
      gImg.fillRect(0, 0, imageW, imageH);
      if (useAA) {
        // Antialiasing hack - just draw a fading-out border around the
        // rectangle
        gImg.setComposite(AlphaComposite.Src);
        int red = graphicsColor.getRed();
        int green = graphicsColor.getRed();
        int blue = graphicsColor.getRed();
        gImg.setColor(new Color(red, green, blue, 50));
        gImg.drawRect(0, 0, imageW - 1, imageH - 1);
        gImg.setColor(new Color(red, green, blue, 100));
        gImg.drawRect(1, 1, imageW - 3, imageH - 3);
        gImg.setColor(new Color(red, green, blue, 150));
        gImg.drawRect(2, 2, imageW - 5, imageH - 5);
        gImg.setColor(new Color(red, green, blue, 200));
        gImg.drawRect(3, 3, imageW - 7, imageH - 7);
        gImg.setColor(new Color(red, green, blue, 225));
        gImg.drawRect(4, 4, imageW - 9, imageH - 9);
      }
    }
    gImg.dispose();
  }
  public void paintComponent(Graphics g) {
    if (image == null) {
      createAnimationImage();
    }
    // Erase the background
    g.setColor(Color.WHITE);
    g.fillRect(0, 0, getWidth(), getHeight());
    // Draw the fading image
    Graphics2D gFade = (Graphics2D) g.create();
    gFade.setComposite(AlphaComposite.SrcOver.derive(opacity));
    gFade.drawImage(image, fadeX, fadeY, null);
    gFade.dispose();
    // Draw the moving image
    if (motionBlur) {
      // Draw previous locations of the image as a trail of
      // ghost images
      if (prevMoveX == null) {
        // blur location array not yet created; create it now
        prevMoveX = new int[blurSize];
        prevMoveY = new int[blurSize];
        trailOpacity = new float[blurSize];
        float incrementalFactor = .2f / (blurSize + 1);
        for (int i = 0; i < blurSize; ++i) {
          // default values, act as flag to not render these
          // until they have real values
          prevMoveX[i] = -1;
          prevMoveY[i] = -1;
          // vary the translucency by the number of the ghost
          // image; the further away it is from the current one,
          // the more faded it will be
          trailOpacity[i] = (.2f - incrementalFactor) - i * incrementalFactor;
        }
      } else {
        Graphics2D gTrail = (Graphics2D) g.create();
        for (int i = 0; i < blurSize; ++i) {
          if (prevMoveX[i] >= 0) {
            // Render each blur image with the appropriate
            // amount of translucency
            gTrail.setComposite(AlphaComposite.SrcOver.derive(trailOpacity[i]));
            gTrail.drawImage(image, prevMoveX[i], prevMoveY[i], null);
          }
        }
        gTrail.dispose();
      }
    }
    g.drawImage(image, moveX, moveY, null);
    if (motionBlur) {
      // shift the ghost positions to add the current position and
      // drop the oldest one
      for (int i = blurSize - 1; i > 0; --i) {
        prevMoveX[i] = prevMoveX[i - 1];
        prevMoveY[i] = prevMoveY[i - 1];
      }
      prevMoveX[0] = moveX;
      prevMoveY[0] = moveY;
    }
  }
  /**
   * This method handles the events from the Swing Timer
   */
  public void actionPerformed(ActionEvent ae) {
    // calculate the fraction elapsed of the animation and call animate()
    // to alter the values accordingly
    long currentTime = System.nanoTime() / 1000000;
    long totalTime = currentTime - cycleStart;
    if (totalTime > CYCLE_TIME) {
      cycleStart = currentTime;
    }
    float fraction = (float) totalTime / CYCLE_TIME;
    fraction = Math.min(1.0f, fraction);
    fraction = 1 - Math.abs(1 - (2 * fraction));
    animate(fraction);
  }
  /**
   * Animate the opacity and location factors, according to the current
   * fraction.
   */
  public void animate(float fraction) {
    float animationFactor;
    if (linear) {
      animationFactor = fraction;
    } else {
      // Our "nonlinear" motion just uses a sin function to get a
      // simple bounce behavior
      animationFactor = (float) Math.sin(fraction * (float) Math.PI / 2);
    }
    // Clamp the value to make sure it does not exceed the bounds
    animationFactor = Math.min(animationFactor, 1.0f);
    animationFactor = Math.max(animationFactor, 0.0f);
    // The opacity, used by the fading animation, will just use the
    // animation fraction directly
    opacity = animationFactor;
    // The move animation will calculate a location based on a linear
    // interpolation between its start and end points using the fraction
    moveX = moveMinX + (int) (.5f + animationFactor * (float) (moveMaxX - moveMinX));
    // redisplay our component with the new animated values
    repaint();
  }
  /**
   * Moves the frame rate up or down by changing the Timer resolution
   */
  private void changeResolution(boolean faster) {
    if (faster) {
      currentResolution -= 5;
    } else {
      currentResolution += 5;
    }
    currentResolution = Math.max(currentResolution, 0);
    currentResolution = Math.min(currentResolution, 500);
    startTimer(currentResolution);
  }
  /**
   * Starts the animation
   */
  private void startTimer(int resolution) {
    if (timer != null) {
      timer.stop();
      timer.setDelay(resolution);
    } else {
      timer = new Timer(resolution, this);
    }
    timer.start();
  }
  /**
   * Toggles various rendering flags
   */
  public void keyPressed(KeyEvent ke) {
    int keyCode = ke.getKeyCode();
    if (keyCode == KeyEvent.VK_B) {
      // B: Motion blur - displays trail of ghost images
      motionBlur = !motionBlur;
    } else if (keyCode == KeyEvent.VK_A) {
      // A: Antialiasing - Displays soft edges around graphics
      useAA = !useAA;
      createAnimationImage();
    } else if (keyCode == KeyEvent.VK_C) {
      // C: Color - Toggles rectangle color between dark and light colors
      alterColor = !alterColor;
      createAnimationImage();
    } else if (keyCode == KeyEvent.VK_I) {
      // I: Image - Toggles use of image or filled rectangle to show how
      // straight edges affect animation perception
      useImage = !useImage;
      createAnimationImage();
    } else if (keyCode == KeyEvent.VK_UP) {
      // Up Arrow: Speed - Speeds up frame rate
      changeResolution(true);
    } else if (keyCode == KeyEvent.VK_DOWN) {
      // Down Arrow: Speed - Slows down frame rate
      changeResolution(false);
    } else if (keyCode == KeyEvent.VK_L) {
      // L: Linearity: Toggles linear/nonlinear motion
      linear = !linear;
    } else if (keyCode >= KeyEvent.VK_1 && keyCode <= KeyEvent.VK_9) {
      // 0-9: Blur size: Toggles size of ghost trail for motion blur
      blurSize = keyCode - KeyEvent.VK_0;
      prevMoveX = prevMoveY = null;
    }
  }
  // Unused KeyListener implementations
  public void keyReleased(KeyEvent ke) {
  }
  public void keyTyped(KeyEvent ke) {
  }
  private static void createAndShowGUI() {
    JFrame f = new JFrame("Smooth Moves");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setSize(moveMaxX + imageW + 50, 300);
    SmoothMoves component = new SmoothMoves();
    f.add(component);
    f.setVisible(true);
    f.addKeyListener(component);
  }
  public static void main(String[] args) {
    Runnable doCreateAndShowGUI = new Runnable() {
      public void run() {
        createAndShowGUI();
      }
    };
    SwingUtilities.invokeLater(doCreateAndShowGUI);
  }
}