Added easing functions for all-around better animations.
These are Robert Penner's easing functions (http://robertpenner.com/easing/), refactored by CharlotteGore to only take a t parameter (https://github.com/CharlotteGore/functional-easing). Licensed under BSD (the former) and MIT (the latter). Related changes: - Added "AnimatedValue" utility class for updating values used in animations. - MenuButton now uses AnimatedValue to handle its animations (still linear by default). - Added in-out-back easings on logo, mods, and various other elements; added out-bounce easings on button menu. Signed-off-by: Jeffrey Han <itdelatrisu@gmail.com>
This commit is contained in:
Jeffrey Han
124
src/itdelatrisu/opsu/ui/animations/AnimatedValue.java
Normal file
124
src/itdelatrisu/opsu/ui/animations/AnimatedValue.java
Normal file
@@ -0,0 +1,124 @@
|
||||
/*
|
||||
* opsu! - an open-source osu! client
|
||||
* Copyright (C) 2014, 2015 Jeffrey Han
|
||||
*
|
||||
* opsu! 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 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* opsu! 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 opsu!. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package itdelatrisu.opsu.ui.animations;
|
||||
|
||||
import itdelatrisu.opsu.Utils;
|
||||
|
||||
/**
|
||||
* Utility class for updating a value using an animation equation.
|
||||
*/
|
||||
public class AnimatedValue {
|
||||
/** The animation duration, in milliseconds. */
|
||||
private int duration;
|
||||
|
||||
/** The current time, in milliseconds. */
|
||||
private int time;
|
||||
|
||||
/** The base value. */
|
||||
private float base;
|
||||
|
||||
/** The maximum difference from the base value. */
|
||||
private float diff;
|
||||
|
||||
/** The current value. */
|
||||
private float value;
|
||||
|
||||
/** The animation equation to use. */
|
||||
private AnimationEquation eqn;
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
* @param duration the total animation duration, in milliseconds
|
||||
* @param min the minimum value
|
||||
* @param max the maximum value
|
||||
* @param eqn the animation equation to use
|
||||
*/
|
||||
public AnimatedValue(int duration, float min, float max, AnimationEquation eqn) {
|
||||
this.time = 0;
|
||||
this.duration = duration;
|
||||
this.value = min;
|
||||
this.base = min;
|
||||
this.diff = max - min;
|
||||
this.eqn = eqn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current value.
|
||||
*/
|
||||
public float getValue() { return value; }
|
||||
|
||||
/**
|
||||
* Returns the current animation time, in milliseconds.
|
||||
*/
|
||||
public int getTime() { return time; }
|
||||
|
||||
/**
|
||||
* Sets the animation time manually.
|
||||
* @param time the new time, in milliseconds
|
||||
*/
|
||||
public void setTime(int time) {
|
||||
this.time = Utils.clamp(time, 0, duration);
|
||||
updateValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the animation duration.
|
||||
* @param duration the new duration, in milliseconds
|
||||
*/
|
||||
public void setDuration(int duration) {
|
||||
this.duration = duration;
|
||||
int newTime = Utils.clamp(time, 0, duration);
|
||||
if (time != newTime) {
|
||||
this.time = newTime;
|
||||
updateValue();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the animation equation to use.
|
||||
* @param eqn the new equation
|
||||
*/
|
||||
public void setEquation(AnimationEquation eqn) {
|
||||
this.eqn = eqn;
|
||||
updateValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the animation by a delta interval.
|
||||
* @param delta the delta interval since the last call.
|
||||
* @return true if an update was applied, false if the animation was not updated
|
||||
*/
|
||||
public boolean update(int delta) {
|
||||
int newTime = Utils.getBoundedValue(time, delta, 0, duration);
|
||||
if (time != newTime) {
|
||||
this.time = newTime;
|
||||
updateValue();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recalculates the value by applying the animation equation with the current time.
|
||||
*/
|
||||
private void updateValue() {
|
||||
float t = eqn.calc((float) time / duration);
|
||||
this.value = base + (t * diff);
|
||||
}
|
||||
}
|
||||
309
src/itdelatrisu/opsu/ui/animations/AnimationEquation.java
Normal file
309
src/itdelatrisu/opsu/ui/animations/AnimationEquation.java
Normal file
@@ -0,0 +1,309 @@
|
||||
/*
|
||||
* opsu! - an open-source osu! client
|
||||
* Copyright (C) 2014, 2015 Jeffrey Han
|
||||
*
|
||||
* opsu! 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 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* opsu! 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 opsu!. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package itdelatrisu.opsu.ui.animations;
|
||||
|
||||
|
||||
/*
|
||||
* These equations are copyright (c) 2001 Robert Penner, all rights reserved,
|
||||
* and are open source under the BSD License.
|
||||
* http://www.opensource.org/licenses/bsd-license.php
|
||||
*
|
||||
* 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 author nor the names of 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Easing functions for animations.
|
||||
*
|
||||
* @author Robert Penner (<a href="http://robertpenner.com/easing/">http://robertpenner.com/easing/</a>)
|
||||
* @author CharlotteGore (<a href="https://github.com/CharlotteGore/functional-easing">https://github.com/CharlotteGore/functional-easing</a>)
|
||||
*/
|
||||
public enum AnimationEquation {
|
||||
/* Linear */
|
||||
LINEAR {
|
||||
@Override
|
||||
public float calc(float t) { return t; }
|
||||
},
|
||||
|
||||
/* Quadratic */
|
||||
IN_QUAD {
|
||||
@Override
|
||||
public float calc(float t) { return t * t; }
|
||||
},
|
||||
OUT_QUAD {
|
||||
@Override
|
||||
public float calc(float t) { return -1 * t * (t - 2); }
|
||||
},
|
||||
IN_OUT_QUAD {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * t * t;
|
||||
t = t - 1;
|
||||
return -0.5f * (t * (t - 2) - 1);
|
||||
}
|
||||
},
|
||||
|
||||
/* Cubic */
|
||||
IN_CUBIC {
|
||||
@Override
|
||||
public float calc(float t) { return t * t * t; }
|
||||
},
|
||||
OUT_CUBIC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t - 1;
|
||||
return t * t * t + 1;
|
||||
}
|
||||
},
|
||||
IN_OUT_CUBIC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * t * t * t;
|
||||
t = t - 2;
|
||||
return 0.5f * (t * t * t + 2);
|
||||
}
|
||||
},
|
||||
|
||||
/* Quartic */
|
||||
IN_QUART {
|
||||
@Override
|
||||
public float calc(float t) { return t * t * t * t; }
|
||||
},
|
||||
OUT_QUART {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t - 1;
|
||||
return -1 * (t * t * t * t - 1);
|
||||
}
|
||||
},
|
||||
IN_OUT_QUART {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * t * t * t * t;
|
||||
t = t - 2;
|
||||
return -0.5f * (t * t * t * t - 2);
|
||||
}
|
||||
},
|
||||
|
||||
/* Quintic */
|
||||
IN_QUINT {
|
||||
@Override
|
||||
public float calc(float t) { return t * t * t * t * t; }
|
||||
},
|
||||
OUT_QUINT {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t - 1;
|
||||
return (t * t * t * t * t + 1);
|
||||
}
|
||||
},
|
||||
IN_OUT_QUINT {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * t * t * t * t * t;
|
||||
t = t - 2;
|
||||
return 0.5f * (t * t * t * t * t + 2);
|
||||
}
|
||||
},
|
||||
|
||||
/* Sine */
|
||||
IN_SINE {
|
||||
@Override
|
||||
public float calc(float t) { return -1 * (float) Math.cos(t * (Math.PI / 2)) + 1; }
|
||||
},
|
||||
OUT_SINE {
|
||||
@Override
|
||||
public float calc(float t) { return (float) Math.sin(t * (Math.PI / 2)); }
|
||||
},
|
||||
IN_OUT_SINE {
|
||||
@Override
|
||||
public float calc(float t) { return (float) (Math.cos(Math.PI * t) - 1) / -2; }
|
||||
},
|
||||
|
||||
/* Exponential */
|
||||
IN_EXPO {
|
||||
@Override
|
||||
public float calc(float t) { return (t == 0) ? 0 : (float) Math.pow(2, 10 * (t - 1)); }
|
||||
},
|
||||
OUT_EXPO {
|
||||
@Override
|
||||
public float calc(float t) { return (t == 1) ? 1 : (float) -Math.pow(2, -10 * t) + 1; }
|
||||
},
|
||||
IN_OUT_EXPO {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t == 0 || t == 1)
|
||||
return t;
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * (float) Math.pow(2, 10 * (t - 1));
|
||||
t = t - 1;
|
||||
return 0.5f * ((float) -Math.pow(2, -10 * t) + 2);
|
||||
}
|
||||
},
|
||||
|
||||
/* Circular */
|
||||
IN_CIRC {
|
||||
@Override
|
||||
public float calc(float t) { return -1 * ((float) Math.sqrt(1 - t * t) - 1); }
|
||||
},
|
||||
OUT_CIRC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t - 1;
|
||||
return (float) Math.sqrt(1 - t * t);
|
||||
}
|
||||
},
|
||||
IN_OUT_CIRC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return -0.5f * ((float) Math.sqrt(1 - t * t) - 1);
|
||||
t = t - 2;
|
||||
return 0.5f * ((float) Math.sqrt(1 - t * t) + 1);
|
||||
}
|
||||
},
|
||||
|
||||
/* Back */
|
||||
IN_BACK {
|
||||
@Override
|
||||
public float calc(float t) { return t * t * ((OVERSHOOT + 1) * t - OVERSHOOT); }
|
||||
},
|
||||
OUT_BACK {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
t = t - 1;
|
||||
return t * t * ((OVERSHOOT + 1) * t + OVERSHOOT) + 1;
|
||||
}
|
||||
},
|
||||
IN_OUT_BACK {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
float overshoot = OVERSHOOT * 1.525f;
|
||||
t = t * 2;
|
||||
if (t < 1)
|
||||
return 0.5f * (t * t * ((overshoot + 1) * t - overshoot));
|
||||
t = t - 2;
|
||||
return 0.5f * (t * t * ((overshoot + 1) * t + overshoot) + 2);
|
||||
}
|
||||
},
|
||||
|
||||
/* Bounce */
|
||||
IN_BOUNCE {
|
||||
@Override
|
||||
public float calc(float t) { return 1 - OUT_BOUNCE.calc(1 - t); }
|
||||
},
|
||||
OUT_BOUNCE {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t < 0.36363636f)
|
||||
return 7.5625f * t * t;
|
||||
else if (t < 0.72727273f) {
|
||||
t = t - 0.54545454f;
|
||||
return 7.5625f * t * t + 0.75f;
|
||||
} else if (t < 0.90909091f) {
|
||||
t = t - 0.81818182f;
|
||||
return 7.5625f * t * t + 0.9375f;
|
||||
} else {
|
||||
t = t - 0.95454546f;
|
||||
return 7.5625f * t * t + 0.984375f;
|
||||
}
|
||||
}
|
||||
},
|
||||
IN_OUT_BOUNCE {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t < 0.5f)
|
||||
return IN_BOUNCE.calc(t * 2) * 0.5f;
|
||||
return OUT_BOUNCE.calc(t * 2 - 1) * 0.5f + 0.5f;
|
||||
}
|
||||
},
|
||||
|
||||
/* Elastic */
|
||||
IN_ELASTIC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t == 0 || t == 1)
|
||||
return t;
|
||||
float period = 0.3f;
|
||||
t = t - 1;
|
||||
return -((float) Math.pow(2, 10 * t) * (float) Math.sin(((t - period / 4) * (Math.PI * 2)) / period));
|
||||
}
|
||||
},
|
||||
OUT_ELASTIC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t == 0 || t == 1)
|
||||
return t;
|
||||
float period = 0.3f;
|
||||
return (float) Math.pow(2, -10 * t) * (float) Math.sin((t - period / 4) * (Math.PI * 2) / period) + 1;
|
||||
}
|
||||
},
|
||||
IN_OUT_ELASTIC {
|
||||
@Override
|
||||
public float calc(float t) {
|
||||
if (t == 0 || t == 1)
|
||||
return t;
|
||||
float period = 0.44999996f;
|
||||
t = t * 2 - 1;
|
||||
if (t < 0)
|
||||
return -0.5f * ((float) Math.pow(2, 10 * t) * (float) Math.sin((t - period / 4) * (Math.PI * 2) / period));
|
||||
return (float) Math.pow(2, -10 * t) * (float) Math.sin((t - period / 4) * (Math.PI * 2) / period) * 0.5f + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/** Overshoot constant for "back" easings. */
|
||||
private static final float OVERSHOOT = 1.70158f;
|
||||
|
||||
/**
|
||||
* Calculates a new {@code t} value using the animation equation.
|
||||
* @param t the raw {@code t} value [0,1]
|
||||
* @return the new {@code t} value [0,1]
|
||||
*/
|
||||
public abstract float calc(float t);
|
||||
}
|
||||
Reference in New Issue
Block a user