More easing types, cleanup

src/mightypork/rogue/App.java

@@ -9,10 +9,9 @@ import javax.swing.JOptionPane;
 
 import mightypork.rogue.display.DisplaySystem;
 import mightypork.rogue.display.Screen;
-import mightypork.rogue.display.ScreenSplash;
+import mightypork.rogue.display.ScreenTestAnimations;
 import mightypork.rogue.input.InputSystem;
 import mightypork.rogue.input.KeyStroke;
-import mightypork.rogue.input.events.MouseMotionEvent;
 import mightypork.rogue.sounds.SoundSystem;
 import mightypork.rogue.tasks.TaskTakeScreenshot;
 import mightypork.rogue.util.Utils;
@@ -24,7 +23,6 @@ import mightypork.utils.time.TimerDelta;
 import mightypork.utils.time.TimerInterpolating;
 
 import org.lwjgl.input.Keyboard;
-import org.lwjgl.opengl.Display;
 
 
 public class App implements Destroyable {
@@ -273,28 +271,20 @@ public class App implements Destroyable {
 
 	/** timer */
 	private TimerDelta timerRender;
-	private TimerInterpolating timerGui;
 
 
 	private void mainLoop()
 	{
-		screen = new ScreenSplash();
+		screen = new ScreenTestAnimations();
 
 		screen.setActive(true);
 
 		timerRender = new TimerDelta();
-		timerGui = new TimerInterpolating(Const.FPS_GUI_UPDATE);
 
 		while (!display.isCloseRequested()) {
 			display.beginFrame();
 
-			// gui update
-			timerGui.sync();
-			int ticks = timerGui.getSkipped();
-			if (ticks >= 1) {
 			input.poll();
-				timerGui.startNewFrame();
-			}
 
 			double delta = timerRender.getDelta();
 

src/mightypork/rogue/display/DisplaySystem.java

@@ -6,19 +6,17 @@ import static org.lwjgl.opengl.GL11.*;
 import java.awt.image.BufferedImage;
 import java.nio.ByteBuffer;
 
-import org.lwjgl.BufferUtils;
-import org.lwjgl.LWJGLException;
-import org.lwjgl.opengl.Display;
-import org.lwjgl.opengl.DisplayMode;
-
 import mightypork.rogue.App;
-import mightypork.rogue.Const;
 import mightypork.rogue.display.events.ScreenChangeEvent;
 import mightypork.utils.logging.Log;
 import mightypork.utils.math.coord.Coord;
 import mightypork.utils.patterns.Destroyable;
 import mightypork.utils.patterns.Initializable;
-import mightypork.utils.time.Updateable;
+
+import org.lwjgl.BufferUtils;
+import org.lwjgl.LWJGLException;
+import org.lwjgl.opengl.Display;
+import org.lwjgl.opengl.DisplayMode;
 
 
 public class DisplaySystem implements Initializable, Destroyable {
@@ -33,6 +31,7 @@ public class DisplaySystem implements Initializable, Destroyable {
 		initialize();
 	}
 
+
 	@Override
 	public void initialize()
 	{
@@ -43,6 +42,7 @@ public class DisplaySystem implements Initializable, Destroyable {
 		initialized = true;
 	}
 
+
 	/**
 	 * Initialize event channels
 	 */
@@ -51,6 +51,7 @@ public class DisplaySystem implements Initializable, Destroyable {
 		App.msgbus().registerMessageType(ScreenChangeEvent.class, ScreenChangeEvent.Listener.class);
 	}
 
+
 	@Override
 	public void destroy()
 	{

src/mightypork/rogue/display/Screen.java

@@ -2,19 +2,15 @@ package mightypork.rogue.display;
 
 
 import static org.lwjgl.opengl.GL11.*;
-
-import java.util.Random;
-
 import mightypork.rogue.App;
 import mightypork.rogue.display.events.ScreenChangeEvent;
 import mightypork.rogue.input.KeyBinder;
 import mightypork.rogue.input.KeyBindingPool;
 import mightypork.rogue.input.KeyStroke;
 import mightypork.rogue.input.events.KeyboardEvent;
-import mightypork.rogue.input.events.MouseMotionEvent;
 import mightypork.rogue.input.events.MouseButtonEvent;
+import mightypork.rogue.input.events.MouseMotionEvent;
 import mightypork.utils.math.coord.Coord;
-import mightypork.utils.patterns.Destroyable;
 import mightypork.utils.patterns.Initializable;
 import mightypork.utils.time.Updateable;
 
@@ -54,6 +50,7 @@ public abstract class Screen implements KeyBinder, Updateable, Initializable, Ke
 
 	/**
 	 * Prepare for being shown
+	 * 
 	 * @param shown true to show, false to hide
 	 */
 	public final void setActive(boolean shown)
@@ -113,11 +110,13 @@ public abstract class Screen implements KeyBinder, Updateable, Initializable, Ke
 
 	/**
 	 * Initialize screen layout and key bindings.<br>
-	 * Called when the screen is created, not when it comes to front. For that, use onEnter().
+	 * Called when the screen is created, not when it comes to front. For that,
+	 * use onEnter().
 	 */
 	@Override
 	public abstract void initialize();
 
+
 	/**
 	 * Called when the screen becomes active
 	 */
@@ -172,6 +171,9 @@ public abstract class Screen implements KeyBinder, Updateable, Initializable, Ke
 	}
 
 
+	/**
+	 * Update and render the screen
+	 */
 	@Override
 	public final void update(double delta)
 	{

src/mightypork/rogue/display/ScreenSplash.java

@@ -1,167 +0,0 @@
-package mightypork.rogue.display;
-
-
-import org.lwjgl.input.Keyboard;
-import org.lwjgl.opengl.Display;
-
-import mightypork.rogue.App;
-import mightypork.rogue.input.KeyStroke;
-import mightypork.rogue.input.events.MouseButtonEvent;
-import mightypork.rogue.input.events.MouseMotionEvent;
-import mightypork.rogue.util.RenderUtils;
-import mightypork.utils.math.Polar;
-import mightypork.utils.math.color.RGB;
-import mightypork.utils.math.coord.Coord;
-import mightypork.utils.math.easing.Easing;
-import mightypork.utils.time.AnimDouble;
-import mightypork.utils.time.AnimDoubleDeg;
-
-
-public class ScreenSplash extends Screen {
-
-	private AnimDoubleDeg degAnim = new AnimDoubleDeg(0, Easing.SINE);
-
-	//@formatter:off
-	private AnimDouble[] anims = new AnimDouble[] {
-			new AnimDouble(0, Easing.NONE),
-			new AnimDouble(0, Easing.LINEAR),
-			
-			new AnimDouble(0, Easing.QUADRATIC_IN),
-			new AnimDouble(0, Easing.QUADRATIC_OUT),
-			new AnimDouble(0, Easing.QUADRATIC),
-			
-			new AnimDouble(0, Easing.CUBIC_IN),
-			new AnimDouble(0, Easing.CUBIC_OUT),
-			new AnimDouble(0, Easing.CUBIC),
-			
-			new AnimDouble(0, Easing.QUADRATIC_IN),
-			new AnimDouble(0, Easing.QUADRATIC_OUT),
-			new AnimDouble(0, Easing.QUADRATIC),
-			
-			new AnimDouble(0, Easing.QUINTIC_IN),
-			new AnimDouble(0, Easing.QUINTIC_OUT),
-			new AnimDouble(0, Easing.QUINTIC_IN_OUT),
-			
-			new AnimDouble(0, Easing.EXPO_IN),
-			new AnimDouble(0, Easing.EXPO_OUT),
-			new AnimDouble(0, Easing.EXPO),
-			
-			new AnimDouble(0, Easing.SINE_IN),
-			new AnimDouble(0, Easing.SINE_OUT),
-			new AnimDouble(0, Easing.SINE),
-			
-			new AnimDouble(0, Easing.CIRC_IN),
-			new AnimDouble(0, Easing.CIRC_OUT),
-			new AnimDouble(0, Easing.CIRC),
-	};
-	//@formatter:on
-
-	@Override
-	public void initialize()
-	{
-		bindKeyStroke(new KeyStroke(Keyboard.KEY_RIGHT), new Runnable() {
-
-			@Override
-			public void run()
-			{
-				for (AnimDouble a : anims) {
-					a.animate(0, 1, 3);
-				}
-			}
-		});
-
-		bindKeyStroke(new KeyStroke(Keyboard.KEY_LEFT), new Runnable() {
-
-			@Override
-			public void run()
-			{
-				for (AnimDouble a : anims) {
-					a.animate(1, 0, 3);
-				}
-			}
-		});
-	}
-
-
-	@Override
-	protected void renderScreen()
-	{
-		double screenH = Display.getHeight();
-		double screenW = Display.getWidth();
-		double perBoxH = screenH / anims.length;
-		double padding = perBoxH*0.1;
-		double boxSide = perBoxH-padding*2;
-
-		for (int i = 0; i < anims.length; i++) {
-			AnimDouble a = anims[i];
-
-			RenderUtils.setColor(i%3==0?RGB.GREEN:RGB.BLUE);
-			RenderUtils.quadSize(
-					padding + a.getCurrentValue() * (screenW - perBoxH - padding*2),
-					screenH - perBoxH * i - perBoxH + padding,
-					boxSide,
-					boxSide
-			);
-		}
-
-		RenderUtils.setColor(RGB.YELLOW);
-		RenderUtils.translate(new Coord(Display.getWidth() / 2, Display.getHeight() / 2));
-		RenderUtils.rotateZ(degAnim.getCurrentValue());
-		RenderUtils.quadSize(-10, -10, 20, 200);
-	}
-
-
-	@Override
-	public void receive(MouseMotionEvent event)
-	{
-	}
-
-
-	@Override
-	public void receive(MouseButtonEvent event)
-	{
-		if(event.isDown()) {
-			Coord vec = App.disp().getSize().half().vecTo(event.getPos());
-
-			Polar p = Polar.fromCoord(vec);
-
-			degAnim.fadeTo(p.getAngleDeg() - 90, 0.2);
-		}
-	}
-
-
-	@Override
-	protected void onEnter()
-	{
-		// TODO Auto-generated method stub
-
-	}
-
-
-	@Override
-	protected void onLeave()
-	{
-		// TODO Auto-generated method stub
-
-	}
-
-
-	@Override
-	protected void onSizeChanged(Coord size)
-	{
-		// TODO Auto-generated method stub
-
-	}
-
-
-	@Override
-	protected void updateScreen(double delta)
-	{
-		degAnim.update(delta);
-
-		for (AnimDouble a : anims) {
-			a.update(delta);
-		}
-	}
-
-}

src/mightypork/rogue/display/ScreenTestAnimations.java

@@ -0,0 +1,200 @@
+package mightypork.rogue.display;
+
+
+import java.util.Random;
+
+import mightypork.rogue.App;
+import mightypork.rogue.input.KeyStroke;
+import mightypork.rogue.input.events.MouseButtonEvent;
+import mightypork.rogue.input.events.MouseMotionEvent;
+import mightypork.rogue.util.RenderUtils;
+import mightypork.utils.math.Polar;
+import mightypork.utils.math.color.RGB;
+import mightypork.utils.math.coord.Coord;
+import mightypork.utils.math.easing.Easing;
+import mightypork.utils.time.animation.AnimDouble;
+import mightypork.utils.time.animation.AnimDoubleDeg;
+
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.opengl.Display;
+
+
+public class ScreenTestAnimations extends Screen {
+	
+	private Random rand = new Random();
+
+	private AnimDoubleDeg degAnim = new AnimDoubleDeg(0, Easing.ELASTIC_OUT);
+
+	//@formatter:off
+	private AnimDouble[] anims = new AnimDouble[] {
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			new AnimDouble(0, Easing.BOUNCE_OUT),
+			
+//			new AnimDouble(0, Easing.NONE),
+//			new AnimDouble(0, Easing.LINEAR),
+//			
+//			new AnimDouble(0, Easing.QUADRATIC_IN),
+//			new AnimDouble(0, Easing.QUADRATIC_OUT),
+//			new AnimDouble(0, Easing.QUADRATIC_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.CUBIC_IN),
+//			new AnimDouble(0, Easing.CUBIC_OUT),
+//			new AnimDouble(0, Easing.CUBIC_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.QUADRATIC_IN),
+//			new AnimDouble(0, Easing.QUADRATIC_OUT),
+//			new AnimDouble(0, Easing.QUADRATIC_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.QUINTIC_IN),
+//			new AnimDouble(0, Easing.QUINTIC_OUT),
+//			new AnimDouble(0, Easing.QUINTIC_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.EXPO_IN),
+//			new AnimDouble(0, Easing.EXPO_OUT),
+//			new AnimDouble(0, Easing.EXPO_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.SINE_IN),
+//			new AnimDouble(0, Easing.SINE_OUT),
+//			new AnimDouble(0, Easing.SINE_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.CIRC_IN),
+//			new AnimDouble(0, Easing.CIRC_OUT),
+//			new AnimDouble(0, Easing.CIRC_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.BOUNCE_IN),
+//			new AnimDouble(0, Easing.BOUNCE_OUT),
+//			new AnimDouble(0, Easing.BOUNCE_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.BACK_IN),
+//			new AnimDouble(0, Easing.BACK_OUT),
+//			new AnimDouble(0, Easing.BACK_IN_OUT),
+//			
+//			new AnimDouble(0, Easing.ELASTIC_IN),
+//			new AnimDouble(0, Easing.ELASTIC_OUT),
+//			new AnimDouble(0, Easing.ELASTIC_IN_OUT),
+	};
+	//@formatter:on
+
+	@Override
+	public void initialize()
+	{
+		bindKeyStroke(new KeyStroke(Keyboard.KEY_RIGHT), new Runnable() {
+
+			@Override
+			public void run()
+			{
+				for (AnimDouble a : anims) {
+					a.animate(0, 1, 1+rand.nextDouble()*1);
+				}
+			}
+		});
+
+		bindKeyStroke(new KeyStroke(Keyboard.KEY_LEFT), new Runnable() {
+
+			@Override
+			public void run()
+			{
+				for (AnimDouble a : anims) {
+					a.animate(1, 0, 1+rand.nextDouble()*1);
+				}
+			}
+		});
+	}
+
+
+	@Override
+	protected void renderScreen()
+	{
+		double screenH = Display.getHeight();
+		double screenW = Display.getWidth();
+		double perBoxH = screenH / anims.length;
+		double padding = perBoxH * 0.1;
+		double boxSide = perBoxH - padding * 2;
+
+		for (int i = 0; i < anims.length; i++) {
+			AnimDouble a = anims[i];
+
+			RenderUtils.setColor(RGB.GREEN);
+			RenderUtils.quadSize(padding + a.getCurrentValue() * (screenW - perBoxH), screenH - perBoxH * i - perBoxH + padding, boxSide, boxSide);
+		}
+
+		RenderUtils.setColor(RGB.YELLOW);
+		RenderUtils.translate(new Coord(Display.getWidth() / 2, Display.getHeight() / 2));
+		RenderUtils.rotateZ(degAnim.getCurrentValue());
+		RenderUtils.quadSize(-10, -10, 20, 200);
+	}
+
+
+	@Override
+	public void receive(MouseMotionEvent event)
+	{
+		//
+	}
+
+
+	@Override
+	public void receive(MouseButtonEvent event)
+	{
+		if (event.isDown()) {
+			Coord vec = App.disp().getSize().half().vecTo(event.getPos());
+
+			Polar p = Polar.fromCoord(vec);
+
+			degAnim.fadeTo(p.getAngleDeg() - 90, 1.5);
+		}
+	}
+
+
+	@Override
+	protected void onEnter()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+
+	@Override
+	protected void onLeave()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+
+	@Override
+	protected void onSizeChanged(Coord size)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+
+	@Override
+	protected void updateScreen(double delta)
+	{
+		degAnim.update(delta);
+
+		for (AnimDouble a : anims) {
+			a.update(delta);
+		}
+	}
+
+}

src/mightypork/rogue/display/constraints/Constraint.java

@@ -1,5 +1,6 @@
 package mightypork.rogue.display.constraints;
 
+
 import mightypork.utils.math.coord.Coord;
 
 
@@ -13,7 +14,8 @@ public abstract class Constraint implements ConstraintContext {
 	}
 
 
-	public void setContext(ConstraintContext context) {
+	public void setContext(ConstraintContext context)
+	{
 		this.context = context;
 	}
 
@@ -23,11 +25,15 @@ public abstract class Constraint implements ConstraintContext {
 		return context;
 	}
 
-	protected Coord origin() {
+
+	protected Coord origin()
+	{
 		return context.getRect().getOrigin();
 	}
 
-	protected Coord size() {
+
+	protected Coord size()
+	{
 		return context.getRect().getSize();
 	}
 

src/mightypork/rogue/display/constraints/ConstraintContext.java

@@ -1,9 +1,10 @@
 package mightypork.rogue.display.constraints;
 
-import mightypork.utils.math.coord.Coord;
+
 import mightypork.utils.math.coord.Rect;
 
 
 public interface ConstraintContext {
+
 	public Rect getRect();
 }

src/mightypork/rogue/input/InputSystem.java

@@ -8,6 +8,7 @@ import mightypork.rogue.input.events.MouseMotionEvent;
 import mightypork.utils.math.coord.Coord;
 import mightypork.utils.patterns.Destroyable;
 import mightypork.utils.patterns.Initializable;
+
 import org.lwjgl.LWJGLException;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;

src/mightypork/rogue/input/KeyBinder.java

@@ -14,6 +14,7 @@ public interface KeyBinder {
 
 	/**
 	 * Remove handler from a keystroke (id any)
+	 * 
 	 * @param stroke stroke
 	 */
 	abstract void unbindKeyStroke(KeyStroke stroke);

src/mightypork/rogue/input/KeyBindingPool.java

@@ -42,6 +42,7 @@ public class KeyBindingPool implements KeyBinder, KeyboardEvent.Listener {
 
 	/**
 	 * Remove handler from keystroke (id any)
+	 * 
 	 * @param stroke stroke
 	 */
 	@Override
@@ -58,6 +59,7 @@ public class KeyBindingPool implements KeyBinder, KeyboardEvent.Listener {
 		}
 	}
 
+
 	@Override
 	public void receive(KeyboardEvent event)
 	{

src/mightypork/rogue/input/events/KeyboardEvent.java

@@ -1,10 +1,10 @@
 package mightypork.rogue.input.events;
 
 
-import org.lwjgl.input.Keyboard;
-
 import mightypork.utils.patterns.subscription.Handleable;
 
+import org.lwjgl.input.Keyboard;
+
 
 /**
  * A keyboard event
@@ -42,6 +42,7 @@ public class KeyboardEvent implements Handleable<KeyboardEvent.Listener> {
 		return down;
 	}
 
+
 	/**
 	 * @return true if key was just released
 	 */
@@ -76,6 +77,7 @@ public class KeyboardEvent implements Handleable<KeyboardEvent.Listener> {
 		public void receive(KeyboardEvent event);
 	}
 
+
 	@Override
 	public String toString()
 	{

src/mightypork/rogue/sounds/LoopPlayer.java

@@ -2,9 +2,9 @@ package mightypork.rogue.sounds;
 
 
 import mightypork.utils.objects.Mutable;
-import mightypork.utils.time.AnimDouble;
 import mightypork.utils.time.Pauseable;
 import mightypork.utils.time.Updateable;
+import mightypork.utils.time.animation.AnimDouble;
 
 import org.lwjgl.openal.AL10;
 

src/mightypork/rogue/sounds/SoundSystem.java

@@ -34,7 +34,6 @@ public class SoundSystem implements Updateable, Destroyable {
 
 	private static Coord listener = new Coord();
 
-	
 	static {
 		// initialize sound system
 		SoundStore.get().setMaxSources(MAX_SOURCES);
@@ -118,12 +117,13 @@ public class SoundSystem implements Updateable, Destroyable {
 
 	/**
 	 * Create {@link AudioX} for a resource
+	 * 
 	 * @param res a resource name
 	 * @return the resource
-	 * 
 	 * @throws IllegalArgumentException if resource is already registered
 	 */
-	private AudioX getResource(String res) {
+	private AudioX getResource(String res)
+	{
 		AudioX a = new AudioX(res);
 		if (resources.contains(a)) throw new IllegalArgumentException("Sound resource " + res + " is already registered.");
 		resources.add(a);

src/mightypork/rogue/util/RenderUtils.java

@@ -4,7 +4,6 @@ package mightypork.rogue.util;
 import static org.lwjgl.opengl.GL11.*;
 import mightypork.rogue.textures.TextureManager;
 import mightypork.rogue.textures.TxQuad;
-import mightypork.utils.math.Calc.Deg;
 import mightypork.utils.math.color.HSV;
 import mightypork.utils.math.color.RGB;
 import mightypork.utils.math.coord.Coord;

src/mightypork/rogue/util/Utils.java

@@ -7,7 +7,9 @@ package mightypork.rogue.util;
  * @author MightyPork
  */
 public class Utils {
-	public static Thread runAsThread(Runnable r) {
+
+	public static Thread runAsThread(Runnable r)
+	{
 		Thread t = new Thread(r);
 		t.start();
 		return t;

src/mightypork/utils/math/coord/CoordAnimated.java

@@ -1,5 +1,6 @@
 package mightypork.utils.math.coord;
 
+
 import mightypork.utils.math.Calc;
 import mightypork.utils.time.Updateable;
 
@@ -16,6 +17,7 @@ public class CoordAnimated extends Coord implements Updateable {
 	private Coord start;
 	private double time = 0;
 
+
 	/**
 	 * Update delta timing
 	 * 
@@ -34,6 +36,7 @@ public class CoordAnimated extends Coord implements Updateable {
 		}
 	}
 
+
 	/**
 	 * Remember position (other changes will be for animation)
 	 */
@@ -45,6 +48,7 @@ public class CoordAnimated extends Coord implements Updateable {
 		offs = Coord.zero();
 	}
 
+
 	/**
 	 * Start animation
 	 * 
@@ -59,6 +63,7 @@ public class CoordAnimated extends Coord implements Updateable {
 		offs = start.vecTo(this);
 	}
 
+
 	/**
 	 * Stop animation, assign to current value
 	 */
@@ -69,6 +74,7 @@ public class CoordAnimated extends Coord implements Updateable {
 		animTime = 0;
 	}
 
+
 	/**
 	 * Get if animation is finished
 	 * 
@@ -79,6 +85,7 @@ public class CoordAnimated extends Coord implements Updateable {
 		return animTime >= time;
 	}
 
+
 	/**
 	 * Get current value (animated)
 	 * 

src/mightypork/utils/math/easing/Easing.java

@@ -1,322 +1,311 @@
 package mightypork.utils.math.easing;
 
 
-import mightypork.utils.math.Calc;
-
-
 /**
- * Easing function.<br>
- * The easing function must be time-invariant and it's domain is [0-1].
+ * EasingFunction function.
  * 
  * @author MightyPork
  */
-public interface Easing {
+public abstract class Easing {
 
 	/**
-	 * Get value of the easing function at given time.
+	 * Get value at time t.
 	 * 
-	 * @param time number in range 0..1
-	 * @return value at given time
+	 * @param t time parameter (t = 1..1)
+	 * @return value at given t (0..1, can exceed if needed)
 	 */
-	public double get(double time);
+	public abstract double get(double t);
 
-	public static final Easing NONE = new Easing() {
 
-		@Override
-		public double get(double time)
+	/**
+	 * Reverse an easing
+	 * 
+	 * @param original original easing
+	 * @return reversed easing
+	 */
+	public static Easing reverse(Easing original)
 	{
-			double t = Calc.clampd(time, 0, 1);
-
-			return (t < 0.5 ? 0 : 1);
+		return new Reverse(original);
 	}
-	};
 
-	public static final Easing LINEAR = new Easing() {
 
-		@Override
-		public double get(double time)
+	/**
+	 * Combine two easings
+	 * 
+	 * @param in initial easing
+	 * @param out terminal easing
+	 * @return product
+	 */
+	public static Easing combine(Easing in, Easing out)
 	{
-			double t = Calc.clampd(time, 0, 1);
-
-			return t;
+		return new Composite(in, out);
 	}
-	};
 
-	public static final Easing QUADRATIC_IN = new Easing() {
 
-		@Override
-		public double get(double time)
+	/**
+	 * Create "bilinear" easing - compose of straight and reverse.
+	 * 
+	 * @param in initial easing
+	 * @return product
+	 */
+	public static Easing inOut(Easing in)
 	{
-			double t = Calc.clampd(time, 0, 1);
-
-			return t * t;
+		return combine(in, reverse(in));
 	}
-	};
 
-	public static final Easing QUADRATIC_OUT = new Easing() {
+	/**
+	 * Reverse EasingFunction
+	 * 
+	 * @author MightyPork
+	 */
+	private static class Reverse extends Easing {
+
+		private Easing ea;
 
-		@Override
-		public double get(double time)
-		{
-			double t = Calc.clampd(time, 0, 1);
 
-			return 1 - (t - 1) * (t - 1);
+		/**
+		 * @param in Easing to reverse
+		 */
+		public Reverse(Easing in) {
+			this.ea = in;
 		}
-	};
 
-	public static final Easing QUADRATIC = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double t = Calc.clampd(time, 0, 1);
-
-			if (t < 0.5) return QUADRATIC_IN.get(2 * t) * 0.5;
-			return 0.5 + QUADRATIC_OUT.get(2 * t - 1) * 0.5;
+			return 1 - ea.get(1 - t);
+		}
 	}
-	};
-
-	public static final Easing CUBIC_IN = new Easing() {
 
-		@Override
-		public double get(double time)
-		{
-			double t = Calc.clampd(time, 0, 1);
+	/**
+	 * Composite EasingFunction (0-0.5 EasingFunction A, 0.5-1 EasingFunction B)
+	 * 
+	 * @author MightyPork
+	 */
+	private static class Composite extends Easing {
 
-			return t * t * t;
-		}
-	};
-	public static final Easing CUBIC_OUT = new Easing() {
+		private Easing in;
+		private Easing out;
 
-		@Override
-		public double get(double time)
-		{
-			double t = Calc.clampd(time, 0, 1);
 
-			return (t - 1) * (t - 1) * (t - 1) + 1;
+		/**
+		 * Create a composite EasingFunction
+		 * 
+		 * @param in initial EasingFunction
+		 * @param out terminal EasingFunction
+		 */
+		public Composite(Easing in, Easing out) {
+			this.in = in;
+			this.out = out;
 		}
-	};
-	public static final Easing CUBIC = new Easing() {
+
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d / 2;
-			if (t < 1) return c / 2 * t * t * t + b;
-			t -= 2;
-			return c / 2 * (t * t * t + 2) + b;
+			if (t < 0.5) return in.get(2 * t) * 0.5;
+			return 0.5 + out.get(2 * t - 1) * 0.5;
+		}
 	}
-	};
-	public static final Easing QUARTIC_IN = new Easing() {
+
+	/** No easing; At t=0.5 goes high. */
+	public static final Easing NONE = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d;
-			return c * t * t * t * t + b;
+			return (t < 0.5 ? 0 : 1);
 		}
 	};
-	public static final Easing QUARTIC_OUT = new Easing() {
+
+	/** Linear (y=t) easing */
+	public static final Easing LINEAR = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			t /= d;
-			t--;
-			return -c * (t * t * t * t - 1) + b;
+			return t;
 		}
 	};
-	public static final Easing QUARTIC = new Easing() {
+
+	/** Quadratic (y=t^2) easing in */
+	public static final Easing QUADRATIC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			t /= d / 2;
-			if (t < 1) return c / 2 * t * t * t * t + b;
-			t -= 2;
-			return -c / 2 * (t * t * t * t - 2) + b;
+			return t * t;
 		}
 	};
-	public static final Easing QUINTIC_IN = new Easing() {
+
+	/** Quadratic (y=t^2) easing out */
+	public static final Easing QUADRATIC_OUT = reverse(QUADRATIC_IN);
+
+	/** Quadratic (y=t^2) easing both */
+	public static final Easing QUADRATIC_IN_OUT = inOut(QUADRATIC_IN);
+
+	/** Cubic (y=t^3) easing in */
+	public static final Easing CUBIC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d;
-			return c * t * t * t * t * t + b;
+			return t * t * t;
 		}
 	};
-	public static final Easing QUINTIC_OUT = new Easing() {
+
+	/** Cubic (y=t^3) easing out */
+	public static final Easing CUBIC_OUT = reverse(CUBIC_IN);
+
+	/** Cubic (y=t^3) easing both */
+	public static final Easing CUBIC_IN_OUT = inOut(CUBIC_IN);
+
+	/** Quartic (y=t^4) easing in */
+	public static final Easing QUARTIC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d;
-			t--;
-			return c * (t * t * t * t * t + 1) + b;
+			return t * t * t * t;
 		}
 	};
-	public static final Easing QUINTIC_IN_OUT = new Easing() {
+
+	/** Quartic (y=t^4) easing out */
+	public static final Easing QUARTIC_OUT = reverse(QUADRATIC_IN);
+
+	/** Quartic (y=t^4) easing both */
+	public static final Easing QUARTIC_IN_OUT = inOut(QUADRATIC_IN);
+
+	/** Quintic (y=t^5) easing in */
+	public static final Easing QUINTIC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d / 2;
-			if (t < 1) return c / 2 * t * t * t * t * t + b;
-			t -= 2;
-			return c / 2 * (t * t * t * t * t + 2) + b;
+			return t * t * t * t * t;
 		}
 	};
+
+	/** Quintic (y=t^5) easing out */
+	public static final Easing QUINTIC_OUT = reverse(QUINTIC_IN);
+
+	/** Quintic (y=t^5) easing both */
+	public static final Easing QUINTIC_IN_OUT = inOut(QUINTIC_IN);
+
+	/** Sine easing in */
 	public static final Easing SINE_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
+			return 1 - Math.cos(t * (Math.PI / 2));
 		}
 	};
-	public static final Easing SINE_OUT = new Easing() {
 
-		@Override
-		public double get(double time)
-		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
+	/** Sine easing out */
+	public static final Easing SINE_OUT = reverse(SINE_IN);
 
-			return c * Math.sin(t / d * (Math.PI / 2)) + b;
-		}
-	};
-	public static final Easing SINE = new Easing() {
+	/** Sine easing both */
+	public static final Easing SINE_IN_OUT = inOut(SINE_IN);
 
-		@Override
-		public double get(double time)
-		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
-		}
-	};
+	/** Exponential easing in */
 	public static final Easing EXPO_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			return c * Math.pow(2, 10 * (t / d - 1)) + b;
+			return Math.pow(2, 10 * (t - 1));
 		}
 	};
-	public static final Easing EXPO_OUT = new Easing() {
 
-		@Override
-		public double get(double time)
-		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
+	/** Exponential easing out */
+	public static final Easing EXPO_OUT = reverse(EXPO_IN);
 
-			return c * (-Math.pow(2, -10 * t / d) + 1) + b;
-		}
-	};
-	public static final Easing EXPO = new Easing() {
+	/** Exponential easing both */
+	public static final Easing EXPO_IN_OUT = inOut(EXPO_IN);
+
+	/** Circular easing in */
+	public static final Easing CIRC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			t /= d / 2;
-			if (t < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
-			t--;
-			return c / 2 * (-Math.pow(2, -10 * t) + 2) + b;
+			return 1 - Math.sqrt(1 - t * t);
 		}
 	};
-	public static final Easing CIRC_IN = new Easing() {
+
+	/** Circular easing out */
+	public static final Easing CIRC_OUT = reverse(CIRC_IN);
+
+	/** Circular easing both */
+	public static final Easing CIRC_IN_OUT = inOut(CIRC_IN);
+
+	/** Bounce easing in */
+	public static final Easing BOUNCE_OUT = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-			t /= d;
-			return -c * (Math.sqrt(1 - t * t) - 1) + b;
+			if (t < (1 / 2.75f)) {
+				return (7.5625f * t * t);
+
+			} else if (t < (2 / 2.75f)) {
+				t -= (1.5f / 2.75f);
+				return (7.5625f * t * t + 0.75f);
+
+			} else if (t < (2.5 / 2.75)) {
+				t -= (2.25f / 2.75f);
+				return (7.5625f * t * t + 0.9375f);
+
+			} else {
+				t -= (2.625f / 2.75f);
+				return (7.5625f * t * t + 0.984375f);
+			}
 		}
 	};
-	public static final Easing CIRC_OUT = new Easing() {
+
+	/** Bounce easing out */
+	public static final Easing BOUNCE_IN = reverse(BOUNCE_OUT);
+
+	/** Bounce easing both */
+	public static final Easing BOUNCE_IN_OUT = inOut(BOUNCE_IN);
+
+	/** Back easing in */
+	public static final Easing BACK_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			t--;
-			return c * Math.sqrt(1 - t * t) + b;
+			float s = 1.70158f;
+			return t * t * ((s + 1) * t - s);
 		}
 	};
-	public static final Easing CIRC = new Easing() {
+
+	/** Back easing out */
+	public static final Easing BACK_OUT = reverse(BACK_IN);
+
+	/** Back easing both */
+	public static final Easing BACK_IN_OUT = inOut(BACK_IN);
+
+	/** Elastic easing in */
+	public static final Easing ELASTIC_IN = new Easing() {
 
 		@Override
-		public double get(double time)
+		public double get(double t)
 		{
-			double d = 1;
-			double t = time;
-			double b = 0;
-			double c = (1 - 0);
-
-			t /= d / 2;
-			if (t < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
-			t -= 2;
-			return c / 2 * (Math.sqrt(1 - t * t) + 1) + b;
+			if (t == 0) return 0;
+			if (t == 1) return 1;
+
+			double p = .3f;
+			double s = p / 4;
+			return -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p));
 		}
 	};
+
+	/** Elastic easing out */
+	public static final Easing ELASTIC_OUT = reverse(ELASTIC_IN);
+
+	/** Elastic easing both */
+	public static final Easing ELASTIC_IN_OUT = inOut(ELASTIC_IN);
 }

src/mightypork/utils/objects/Mutable.java

@@ -71,6 +71,7 @@ public class Mutable<T> {
 		return true;
 	}
 
+
 	@Override
 	public String toString()
 	{

src/mightypork/utils/objects/VarargsParser.java

@@ -15,6 +15,7 @@ import java.util.Map;
  * 
  * 
  * 
+ * 
  * Object[] array = { "one", 1, "two", 4, "three", 9, "four", 16 };
  * Map<String, Integer> args = new VarargsParser<String, Integer>().parse(array);
  * </pre>

src/mightypork/utils/patterns/Destroyable.java

@@ -7,6 +7,7 @@ package mightypork.utils.patterns;
  * @author MightyPork
  */
 public interface Destroyable {
+
 	/**
 	 * Destroy this object
 	 */

src/mightypork/utils/patterns/Initializable.java

@@ -7,6 +7,7 @@ package mightypork.utils.patterns;
  * @author MightyPork
  */
 public interface Initializable {
+
 	/**
 	 * Initialize if not initialized yet
 	 */

src/mightypork/utils/patterns/subscription/MessageBus.java

@@ -1,5 +1,6 @@
 package mightypork.utils.patterns.subscription;
 
+
 import java.util.LinkedHashSet;
 import java.util.Set;
 

src/mightypork/utils/patterns/subscription/MessageChannel.java

@@ -134,6 +134,7 @@ public final class MessageChannel<MESSAGE extends Handleable<CLIENT>, CLIENT> im
 		return true;
 	}
 
+
 	@Override
 	public String toString()
 	{

src/mightypork/utils/time/animation/AnimDouble.java

@@ -1,8 +1,10 @@
-package mightypork.utils.time;
+package mightypork.utils.time.animation;
 
 
 import mightypork.utils.math.Calc;
 import mightypork.utils.math.easing.Easing;
+import mightypork.utils.time.Pauseable;
+import mightypork.utils.time.Updateable;
 
 
 /**
@@ -194,7 +196,12 @@ public class AnimDouble implements Updateable, Pauseable {
 
 		this.from = from;
 		this.to = to;
-		this.duration = time * (1 - getProgressFromValue(current));
+
+		double progress = getProgressFromValue(current);
+
+		this.from = (progress > 0 ? current : from);
+
+		this.duration = time * (1 - progress);
 		this.elapsedTime = 0;
 	}
 
@@ -203,6 +210,8 @@ public class AnimDouble implements Updateable, Pauseable {
 	{
 		double p = 0;
 
+		if (from == to) return 0;
+
 		if (value >= from && value <= to) { // up
 			p = ((value - from) / (to - from));
 		} else if (value >= to && value <= from) { // down

src/mightypork/utils/time/animation/AnimDoubleDeg.java

@@ -1,4 +1,4 @@
-package mightypork.utils.time;
+package mightypork.utils.time.animation;
 
 
 import mightypork.utils.math.Calc;

src/mightypork/utils/time/animation/AnimDoubleRad.java

@@ -1,4 +1,4 @@
-package mightypork.utils.time;
+package mightypork.utils.time.animation;
 
 
 import mightypork.utils.math.Calc;