A simple spring simulation in one dimension : Animation « 2D Graphics GUI « Java






A simple spring simulation in one dimension

   
/*
 *  $Id: FloatSpring.java,v 1.4 2007/06/25 23:00:10 shingoki Exp $
 *
 *  Copyright (c) 2005-2006 shingoki
 *
 *  This file is part of AirCarrier, see http://aircarrier.dev.java.net/
 *
 *    AirCarrier is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.

 *    AirCarrier is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.

 *    You should have received a copy of the GNU General Public License
 *    along with AirCarrier; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/**
 * A simple spring simulation in one dimension Useful for getting a property
 * (for example a position) to move from one value to another, in a smooth
 * looking way. To use, create a spring with appropriate constants (e.g. new
 * FloatSpring(100) is a reasonable value) Then set spring position to the
 * initial value, and update each frame with target parameter as your desired
 * value. The position parameter will "snap to" the desired value.
 * 
 * @author goki
 */
public class FloatSpring {

  float position;

  float springK;

  float dampingK;

  float velocity;

  /**
   * Make a spring with given spring constant and damping constant
   * 
   * @param springK
   *          Spring constant, the higher this is the "tighter" the spring, and
   *          the more force it will exert for a given extension
   * @param dampingK
   *          Damping constant, the higher this is the stronger the damping, and
   *          the more "soggy" the movement.
   */
  public FloatSpring(float springK, float dampingK) {
    super();
    this.position = 0;
    this.springK = springK;
    this.dampingK = dampingK;
    this.velocity = 0;
  }

  /**
   * Create a critically damped spring (or near to critically damped) This
   * spring will quickly move to its target without overshooting
   * 
   * @param springK
   *          The spring constant - the higher this is, the more quickly the
   *          spring will reach its target. A value of 100 gives a reasonable
   *          response in about a second, a higher value gives a faster
   *          response.
   */
  public FloatSpring(float springK) {
    this(springK, (float) (2 * Math.sqrt(springK)));
  }

  /**
   * Update the position of the spring. This updates the "position" as if there
   * were a damped spring stretched between the current position and the target
   * position. That is, the spring will tend to pull the position towards the
   * target, and if the spring is damped the position will eventually settle
   * onto the target.
   * 
   * @param target
   *          The target towards which the spring is pulling the position
   * @param time
   *          The elapsed time in seconds
   */
  public void update(float target, float time) {

    // Set v to target - position, this is the required movement
    float v = position - target;

    // Multiply displacement by spring constant to get spring force,
    // then subtract damping force
    v = v * -springK - velocity * dampingK;

    // v is now a force, so assuming unit mass is is also acceleration.
    // multiply by elapsed time to get velocity change
    velocity += v * time;

    // If velocity isn't valid, zero it
    if (Float.isNaN(velocity) || Float.isInfinite(velocity)) {
      velocity = 0;
    }

    // Change the position at the new velocity, for elapsed time
    position += velocity * time;
  }

  /**
   * @return Damping constant, the higher this is the stronger the damping, and
   *         the more "soggy" the movement.
   */
  public float getDampingK() {
    return dampingK;
  }

  /**
   * @param dampingK
   *          Damping constant, the higher this is the stronger the damping, and
   *          the more "soggy" the movement.
   */
  public void setDampingK(float dampingK) {
    this.dampingK = dampingK;
  }

  /**
   * @return The current position of the simulated spring end point, changes as
   *         simulation is updated
   */
  public float getPosition() {
    return position;
  }

  /**
   * @param position
   *          A new position for simulated spring end point
   */
  public void setPosition(float position) {
    this.position = position;
  }

  /**
   * @return The spring constant - the higher this is, the more quickly the
   *         spring will reach its target
   */
  public float getSpringK() {
    return springK;
  }

  /**
   * @param springK
   *          The spring constant - the higher this is, the more quickly the
   *          spring will reach its target
   */
  public void setSpringK(float springK) {
    this.springK = springK;
  }

  /**
   * @return The current velocity of the position
   */
  public float getVelocity() {
    return velocity;
  }

  /**
   * @param velocity
   *          A new value for the current velocity of the position
   */
  public void setVelocity(float velocity) {
    this.velocity = velocity;
  }
}

   
    
    
  








Related examples in the same category

1.Is Event Dispatcher ThreadIs Event Dispatcher Thread
2.Timer based animation
3.A rotating and scaling rectangle.
4.Fade out an image: image gradually get more transparent until it is completely invisible.
5.Font size animation
6.Hypnosis animationHypnosis animation
7.Noise ImageNoise Image
8.How to create Animation: Paint and threadHow to create Animation: Paint and thread
9.How to create animationHow to create animation
10.Animation: bounce
11.Image BouncerImage Bouncer
12.Text animationText animation
13.Buffered Animation DemoBuffered Animation Demo
14.Bouncing CircleBouncing Circle
15.Hypnosis SpiralHypnosis Spiral
16.Animator DemoAnimator Demo
17.Towers of Hanoi
18.Make your own animation from a series of images
19.Composition technique in this animation.
20.Animated Button
21.Animated Message Panel
22.Animated PasswordField
23.Animated TextField
24.Shows an animated bouncing ball
25.Shows animated bouncing ballsShows animated bouncing balls