// Adapted from source : http://www.robertpenner.com/easing/
public static float Ease(double linearStep, float acceleration, EasingType type) {
float easedStep = acceleration > 0 ? EaseIn(linearStep, type) :
acceleration < 0 ? EaseOut(linearStep, type) :
(float) linearStep;
return MathHelper.Lerp(linearStep, easedStep, Math.Abs(acceleration));
}
public static Vector3 Interp(Spline.Path pts, float t, EasingType ease, bool easeIn, bool easeOut)
{
t = Spline.Ease(t, ease, easeIn, easeOut);
if (pts.Length == 0)
{
return Vector3.zero;
}
if (pts.Length == 1)
{
return pts[0];
}
if (pts.Length == 2)
{
return Vector3.Lerp(pts[0], pts[1], t);
}
if (pts.Length == 3)
{
return QuadBez.Interp(pts[0], pts[2], pts[1], t);
}
if (pts.Length == 4)
{
return CubicBez.Interp(pts[0], pts[3], pts[1], pts[2], t);
}
return CRSpline.Interp(Spline.Wrap(pts), t);
}
public Ease(EasingType type, float duration, object toEase, string mask)
{
_type = type;
_startTime = Time.time;
_value = toEase;
_mask = mask;
}
private static Func<decimal, decimal> FunctionFromType(EasingType easing)
{
switch (easing)
{
case EasingType.Constant:
return x => 1;
case EasingType.Linear:
return x => x;
case EasingType.Quadratic:
return x => DMath.Pow(x, 2);
case EasingType.Cubic:
return x => DMath.Pow(x, 3);
case EasingType.Quartic:
return x => DMath.Pow(x, 4);
case EasingType.Quintic:
return x => DMath.Pow(x, 5);
case EasingType.Sinusoidal:
return x => 1 - DMath.Cos(x * DMath.PI / 2); // Wait... That's not Sine!
case EasingType.Exponential:
return x => DMath.Pow(x, 5);
case EasingType.Circular:
return x => 1 - DMath.Sqrt(1 - x * x);
default:
throw new ArgumentOutOfRangeException();
}
}
public static float EaseOut(double linearStep, EasingType type)
{
switch (type)
{
case EasingType.None:
return 1f;
case EasingType.Linear:
return (float) linearStep;
case EasingType.Sine:
return Easing.Sine.EaseOut(linearStep);
case EasingType.Quadratic:
return Easing.Power.EaseOut(linearStep, 2);
case EasingType.Cubic:
return Easing.Power.EaseOut(linearStep, 3);
case EasingType.Quartic:
return Easing.Power.EaseOut(linearStep, 4);
case EasingType.Quintic:
return Easing.Power.EaseOut(linearStep, 5);
case EasingType.Sextic:
return Easing.Power.EaseOut(linearStep, 6);
case EasingType.Septic:
return Easing.Power.EaseOut(linearStep, 7);
case EasingType.Octic:
return Easing.Power.EaseOut(linearStep, 8);
case EasingType.Nonic:
return Easing.Power.EaseOut(linearStep, 9);
case EasingType.Decic:
return Easing.Power.EaseOut(linearStep, 10);
case EasingType.Circular:
return Easing.Circular.EaseOut(linearStep);
default:
throw new NotImplementedException();
}
}
public static float EaseOut(double linearStep, EasingType type)
{
switch (type)
{
case EasingType.Step: return linearStep < 0.5 ? 0 : 1;
case EasingType.Linear: return (float)linearStep;
case EasingType.Sine: return Sine.EaseOut(linearStep);
case EasingType.Quadratic: return Power.EaseOut(linearStep, 2);
case EasingType.Circular: return Circular.EaseOut(linearStep);
}
throw new NotImplementedException();
}
public static float EaseInOut(double linearStep, EasingType type) {
linearStep = Mathf.Clamp01((float)linearStep);
switch (type) {
case EasingType.Step: return linearStep < 0.5 ? 0 : 1;
case EasingType.Linear: return (float)linearStep;
case EasingType.Sine: return Sine.EaseInOut(linearStep);
case EasingType.Quadratic: return Power.EaseInOut(linearStep, 2);
case EasingType.Cubic: return Power.EaseInOut(linearStep, 3);
case EasingType.Quartic: return Power.EaseInOut(linearStep, 4);
case EasingType.Quintic: return Power.EaseInOut(linearStep, 5);
}
throw new NotImplementedException();
}
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn, bool easeOut)
{
Gizmos.color = Color.white;
Vector3 to = Spline.Interp(pts, 0f);
for (int i = 1; i <= 20; i++)
{
float t2 = (float)i / 20f;
Vector3 vector = Spline.Interp(pts, t2, ease, easeIn, easeOut);
Gizmos.DrawLine(vector, to);
to = vector;
}
Gizmos.color = Color.blue;
Vector3 vector2 = Spline.Interp(pts, t, ease, easeIn, easeOut);
Gizmos.DrawLine(vector2, vector2 + Spline.Velocity(pts, t, ease, easeIn, easeOut));
}
/// <summary>
/// Returns the output of an easing function for a specific time.
/// </summary>
/// <param name="t">The normalized time</param>
/// <param name="easingType">The easing function to use</param>
/// <returns>The eased output</returns>
public static float Ease(float t, EasingType easingType)
{
switch (easingType)
{
case EasingType.ExponentialIn: return Functions.ExponentialIn(t);
case EasingType.ExponentialOut: return Functions.ExponentialOut(t);
case EasingType.ExponentialInOut: return Functions.ExponentialInOut(t);
case EasingType.ExponentialOutIn: return Functions.ExponentialOutIn(t);
case EasingType.SineIn: return Functions.SineIn(t);
case EasingType.SineOut: return Functions.SineOut(t);
case EasingType.SineInOut: return Functions.SineInOut(t);
case EasingType.SineOutIn: return Functions.SineOutIn(t);
case EasingType.CubicIn: return Functions.CubicIn(t);
case EasingType.CubicOut: return Functions.CubicOut(t);
case EasingType.CubicInOut: return Functions.CubicInOut(t);
case EasingType.CubicOutIn: return Functions.CubicOutIn(t);
case EasingType.QuinticIn: return Functions.QuinticIn(t);
case EasingType.QuinticOut: return Functions.QuinticOut(t);
case EasingType.QuinticInOut: return Functions.QuinticInOut(t);
case EasingType.QuinticOutIn: return Functions.QuinticOutIn(t);
case EasingType.CircularIn: return Functions.CircularIn(t);
case EasingType.CircularOut: return Functions.CircularOut(t);
case EasingType.CircularInOut: return Functions.CircularInOut(t);
case EasingType.CircularOutIn: return Functions.CircularOutIn(t);
case EasingType.ElasticIn: return Functions.ElasticIn(t);
case EasingType.ElasticOut: return Functions.ElasticOut(t);
case EasingType.ElasticInOut: return Functions.ElasticInOut(t);
case EasingType.ElasticOutIn: return Functions.ElasticOutIn(t);
case EasingType.QuadraticIn: return Functions.QuadraticIn(t);
case EasingType.QuadraticOut: return Functions.QuadraticOut(t);
case EasingType.QuadraticInOut: return Functions.QuadraticInOut(t);
case EasingType.QuadraticOutIn: return Functions.QuadraticOutIn(t);
case EasingType.QuarticIn: return Functions.QuarticIn(t);
case EasingType.QuarticOut: return Functions.QuarticOut(t);
case EasingType.QuarticInOut: return Functions.QuarticInOut(t);
case EasingType.QuarticOutIn: return Functions.QuarticOutIn(t);
case EasingType.BackIn: return Functions.BackIn(t);
case EasingType.BackOut: return Functions.BackOut(t);
case EasingType.BackInOut: return Functions.BackInOut(t);
case EasingType.BackOutIn: return Functions.BackOutIn(t);
case EasingType.BounceIn: return Functions.BounceIn(t);
case EasingType.BounceOut: return Functions.BounceOut(t);
case EasingType.BounceInOut: return Functions.BounceInOut(t);
case EasingType.BounceOutIn: return Functions.BounceOutIn(t);
default: return Functions.Linear(t);
}
}
// Set this object up to fade-out
public void MakeInvisible(float t = -1.0f, float alpha = 0.0f, EasingType easingType=EasingType.Linear, bool force = false)
{
alphaEaseType = easingType;
alpha = Mathf.Max(0.0f, alpha);
alpha = Mathf.Min(1.0f, alpha);
if( t == 0.0f ) {
if (transform.renderer.material.HasProperty("_Color") ) {
if (GetComponent<DynamicText>() != null) {
DynamicText dt = GetComponent<DynamicText>();
transitionStartColor = dt.color;
transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha);
oldAlpha = dt.color.a;
dt.color = transitionEndColor;
} else {
transitionStartColor = renderer.material.color;
transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha);
oldAlpha = renderer.material.color.a;
renderer.material.color = transitionEndColor;
}
} else {
oldAlpha = transform.renderer.material.GetFloat("_alpha_blend");
transform.renderer.material.SetFloat("_alpha_blend", alpha);
}
m_isVisible = alpha > 0.0f;
// return;
}
duration = (t >= 0.0f ? t : defaultDuration);
stage = 0F;
if (transform.renderer.material.HasProperty("_Color") ) {
if (GetComponent<DynamicText>() != null) {
transitionStartColor = GetComponent<DynamicText>().color;
oldAlpha = transitionStartColor.a;
} else {
transitionStartColor = renderer.material.color;
oldAlpha = renderer.material.color.a;
}
transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha);
} else {
oldAlpha = transform.renderer.material.GetFloat("_alpha_blend");
}
targetAlpha = alpha;
m_isTransitioning = true;
}
public Animation(object obj, string propName, float startValue, float endValue, EaseFunctionDelegate easeFunc,
EasingType easeType)
{
if(propName != null)
{
_property = obj.GetType().GetProperty(propName);
}
else
{
_property = null;
}
PropertyName = propName;
_obj = obj;
_startValue = startValue;
_endValue = endValue;
_easeFunc = easeFunc;
_easeType = easeType;
}
public static Quaternion RotationBetween(Spline.Path pts, float t1, float t2, EasingType ease, bool easeIn, bool easeOut)
{
return Quaternion.LookRotation(Spline.Interp(pts, t2, ease, easeIn, easeOut) - Spline.Interp(pts, t1, ease, easeIn, easeOut));
}
public static Vector3 Interp(Path pts, float t, EasingType ease)
{
return(Interp(pts, t, ease, true));
}
//public
/// <summary>
/// Creates a tween that sets a method. It starts at the specified value and ends at the specified value.
/// </summary>
/// <param name="onUpdate">The method that is called with the new value every time the tween is updated.</param>
/// <param name="start">The starting value.</param>
/// <param name="end">The ending value.</param>
/// <param name="duration">The duration, in milliseconds, of the tween.</param>
/// <param name="type">(optional) The type of easing the tween will use.</param>
/// <returns>The tween that was created.</returns>
public static Tween FromTo(Action <double> onUpdate, double start, double end, double duration, EasingType type = EasingType.Linear)
{
return(new Tween(onUpdate, start, end, duration, type));
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed = 1f, float smoothnessFactor = 100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
maxSpeed *= Time.deltaTime;
pathPosition = Mathf.Clamp01(pathPosition);
var goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
float distance;
while ((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition < 1)
{
currentPosition = goal;
maxSpeed -= distance;
pathPosition = Mathf.Clamp01(pathPosition + 1 / smoothnessFactor);
goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
}
if (distance != 0)
{
currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed);
}
return(currentPosition);
}
private static float Ease(float t, EasingType ease, bool easeIn, bool easeOut)
{
t = Mathf.Clamp01(t);
if (easeIn && easeOut)
{
t = Easing.EaseInOut((double)t, ease);
}
else if (easeIn)
{
t = Easing.EaseIn((double)t, ease);
}
else if (easeOut)
{
t = Easing.EaseOut((double)t, ease);
}
return t;
}
private static float Ease(float t, EasingType ease, bool easeIn)
{
return(Ease(t, ease, easeIn, true));
}
//master function for using EasingType with default parameters
public static float easeWithType(EasingType type, float t)
{
switch (type)
{
case EasingType.EaseNone:
return(easeNone(t));
case EasingType.EaseInQuad:
return(easeInQuad(t));
case EasingType.EaseOutQuad:
return(easeOutQuad(t));
case EasingType.EaseOutInQuad:
return(easeOutInQuad(t));
case EasingType.EaseInCubic:
return(easeInCubic(t));
case EasingType.EaseOutCubic:
return(easeOutCubic(t));
case EasingType.EaseInOutCubic:
return(easeInOutCubic(t));
case EasingType.EaseOutInCubic:
return(easeOutInCubic(t));
case EasingType.EaseInQuart:
return(easeInQuart(t));
case EasingType.EaseOutQuart:
return(easeOutQuart(t));
case EasingType.EaseInOutQuart:
return(easeInOutQuart(t));
case EasingType.EaseOutInQuart:
return(easeOutInQuart(t));
case EasingType.EaseInQuint:
return(easeInQuint(t));
case EasingType.EaseOutQuint:
return(easeOutQuint(t));
case EasingType.EaseInOutQuint:
return(easeInOutQuint(t));
case EasingType.EaseOutInQuint:
return(easeOutInQuint(t));
case EasingType.EaseInSine:
return(easeInSine(t));
case EasingType.EaseOutSine:
return(easeOutSine(t));
case EasingType.EaseInOutSine:
return(easeInOutSine(t));
case EasingType.EaseOutInSine:
return(easeOutInSine(t));
case EasingType.EaseInExpo:
return(easeInExpo(t));
case EasingType.EaseOutExpo:
return(easeOutExpo(t));
case EasingType.EaseInOutExpo:
return(easeInOutExpo(t));
case EasingType.EaseOutInExpo:
return(easeOutInExpo(t));
case EasingType.EaseInCirc:
return(easeInCirc(t));
case EasingType.EaseOutCirc:
return(easeOutCirc(t));
case EasingType.EaseInOutCirc:
return(easeInOutCirc(t));
case EasingType.EaseOutInCirc:
return(easeOutInCirc(t));
case EasingType.EaseInBounce:
return(easeInBounce(t));
case EasingType.EaseOutBounce:
return(easeOutBounce(t));
case EasingType.EaseInOutBounce:
return(easeInOutBounce(t));
case EasingType.EaseOutInBounce:
return(easeOutInBounce(t));
case EasingType.EaseInBack:
return(easeInBack(t));
case EasingType.EaseOutBack:
return(easeOutBack(t));
case EasingType.EaseInOutBack:
return(easeInOutBack(t));
case EasingType.EaseOutInBack:
return(easeOutInBack(t, 1.70158f));
case EasingType.EaseInElastic:
return(easeInElastic(t, 1.25f, 1.5f));
case EasingType.EaseOutElastic:
return(easeOutElastic(t, 1.25f, 1.5f));
case EasingType.EaseInOutElastic:
return(easeInOutElastic(t, 1.25f, 1.5f));
case EasingType.EaseOutInElastic:
return(easeOutInElastic(t, 1.25f, 1.5f));
case EasingType.EaseInAtan:
return(easeInAtan(t));
case EasingType.EaseOutAtan:
return(easeOutAtan(t));
case EasingType.EaseInOutAtan:
return(easeInOutAtan(t));
}
return(t);
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn, bool easeOut)
{
maxSpeed *= Time.deltaTime;
pathPosition = Clamp(pathPosition);
var goal = InterpConstantSpeed(pts, pathPosition, ease, easeIn, easeOut);
float distance;
while ((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition != 1)
{
//currentPosition = goal;
//maxSpeed -= distance;
pathPosition = Clamp(pathPosition + 1 / smoothnessFactor);
goal = InterpConstantSpeed(pts, pathPosition, ease, easeIn, easeOut);
}
if (distance != 0)
{
currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed);
}
return(currentPosition);
}
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn)
{
GizmoDraw(pts, t, ease, easeIn, true);
}
public virtual async UniTask TransitionAsync(Transition transition, float duration, EasingType easingType = EasingType.Linear, CancellationToken cancellationToken = default)
{
if (transitionTweener.Running)
{
transitionTweener.CompleteInstantly();
}
material.UpdateRandomSeed();
material.TransitionProgress = 0;
material.TransitionName = transition.Name;
material.TransitionParams = transition.Parameters;
if (ObjectUtils.IsValid(transition.DissolveTexture))
{
material.DissolveTexture = transition.DissolveTexture;
}
var transitionTexture = RenderTexture.GetTemporary(cameraManager.Camera.scaledPixelWidth, cameraManager.Camera.scaledPixelHeight);
var initialRenderTexture = cameraManager.Camera.targetTexture;
cameraManager.Camera.targetTexture = transitionTexture;
material.TransitionTexture = transitionTexture;
var tween = new FloatTween(material.TransitionProgress, 1, duration, value => material.TransitionProgress = value, false, easingType, material);
await transitionTweener.RunAsync(tween, cancellationToken);
if (cancellationToken.CancelASAP)
{
// Try restore camera target texture before cancellation, otherwise it'll mess when rolling back.
if (cameraManager != null && cameraManager.Camera)
{
cameraManager.Camera.targetTexture = initialRenderTexture;
}
RenderTexture.ReleaseTemporary(transitionTexture);
return;
}
cameraManager.Camera.targetTexture = initialRenderTexture;
SetVisibility(false);
RenderTexture.ReleaseTemporary(transitionTexture);
// In case of rollbacks, revert to the original scene texture.
material.TransitionProgress = 0;
}
public static Vector3 Velocity(Path pts, float t, EasingType ease, bool easeIn)
{
return(Velocity(pts, t, ease, easeIn, true));
}
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease, bool easeIn, bool easeOut)
{
return(Quaternion.LookRotation(Interp(pts, t2, ease, easeIn, easeOut) - Interp(pts, t1, ease, easeIn, easeOut)));
}
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease, bool easeIn)
{
return(RotationBetween(pts, t1, t2, ease, easeIn, true));
}
public static Vector3 Velocity(Spline.Path pts, float t, EasingType ease, bool easeIn)
{
return Spline.Velocity(pts, t, ease, easeIn, true);
}
public FloatTween(float from, float to, float time, Action <float> onTween, bool ignoreTimeScale = false, EasingType easingType = default)
{
StartValue = from;
TargetValue = to;
TweenDuration = time;
EasingType = easingType;
IsTimeScaleIgnored = ignoreTimeScale;
OnFloatTween = onTween;
easingFunction = EasingType.GetEasingFunction();
}
private static float Ease(float t, EasingType ease)
{
return Spline.Ease(t, ease, true);
}
public static Effect EaseDmxValue(Guid queue, int channel, int priority, byte startValue, byte endValue, int duration, EasingType typeIn, EasingType typeOut, EasingExtents extents)
{
Effect handle = new Effect(queue, channel, priority, startValue, endValue, duration, typeIn, typeOut, extents);
QueueEffect(handle);
handle.Start();
return(handle);
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn, bool easeOut)
{
var result = MoveOnPath(pts, currentPosition, ref pathPosition, maxSpeed, smoothnessFactor, ease, easeIn, easeOut);
rotation = result.Equals(currentPosition) ? Quaternion.identity : Quaternion.LookRotation(result - currentPosition);
return(result);
}
public static Effect EaseDmxValue(Guid queue, int channel, int priority, byte startValue, byte endValue, int duration, EasingType typeIn, EasingType typeOut, EasingExtents extents, DateTime when)
{
Effect handle = new Effect(queue, channel, priority, startValue, endValue, duration, typeIn, typeOut, extents);
QueueEffect(handle);
handle.StartIn((int)(when - DateTime.Now).TotalMilliseconds);
return(handle);
}
//constructor
/// <summary>
/// An object used to smoothly translate a field from start to finish with various types of easing. The tween is automatically started upon creation.
/// </summary>
/// <param name="onUpdate">The method that is called with the new value every time the tween is updated.</param>
/// <param name="start">The starting value of the tween.</param>
/// <param name="end">The ending value of the tween.</param>
/// <param name="duration">The duration, in milliseconds, of the tween.</param>
/// <param name="type">(optional) The type of easing the tween will use.</param>
public Tween(Action <double> onUpdate, double start, double end, double duration, EasingType type = EasingType.Linear)
{
if (onUpdate == null)
{
throw new ArgumentNullException("setFunc");
}
if (double.IsNaN(start) || double.IsInfinity(start))
{
throw new InvalidOperationException("start cannot be NaN or infinity.");
}
if (double.IsNaN(end) || double.IsInfinity(end))
{
throw new InvalidOperationException("end cannot be NaN or infinity.");
}
if (double.IsNaN(duration) || double.IsInfinity(duration))
{
throw new InvalidOperationException("duration cannot be NaN or infinity.");
}
if (type == EasingType.None)
{
type = EasingType.Linear;
}
tweens.Add(this);
this.onUpdate = onUpdate;
_start = start;
_end = end;
_duration = duration;
_type = type;
}
/// <summary>
/// Returns an <see cref="EasignFunction"/> delegate that implements the
/// easing equation defined by the <paramref name="easeType"/> argument.
/// </summary>
/// <param name="easeType">The easing equation to be used</param>
public static TweenEasingCallback GetFunction(EasingType easeType)
{
switch (easeType)
{
case EasingType.BackEaseIn:
return(EaseInBack);
case EasingType.BackEaseInOut:
return(EaseInOutBack);
case EasingType.BackEaseOut:
return(EaseOutBack);
case EasingType.Bounce:
return(Bounce);
case EasingType.CircEaseIn:
return(EaseInCirc);
case EasingType.CircEaseInOut:
return(EaseInOutCirc);
case EasingType.CircEaseOut:
return(EaseOutCirc);
case EasingType.CubicEaseIn:
return(EaseInCubic);
case EasingType.CubicEaseInOut:
return(EaseInOutCubic);
case EasingType.CubicEaseOut:
return(EaseOutCubic);
case EasingType.ExpoEaseIn:
return(EaseInExpo);
case EasingType.ExpoEaseInOut:
return(EaseInOutExpo);
case EasingType.ExpoEaseOut:
return(EaseOutExpo);
case EasingType.Linear:
return(Linear);
case EasingType.QuadEaseIn:
return(EaseInQuad);
case EasingType.QuadEaseInOut:
return(EaseInOutQuad);
case EasingType.QuadEaseOut:
return(EaseOutQuad);
case EasingType.QuartEaseIn:
return(EaseInQuart);
case EasingType.QuartEaseInOut:
return(EaseInOutQuart);
case EasingType.QuartEaseOut:
return(EaseOutQuart);
case EasingType.QuintEaseIn:
return(EaseInQuint);
case EasingType.QuintEaseInOut:
return(EaseInOutQuint);
case EasingType.QuintEaseOut:
return(EaseOutQuint);
case EasingType.SineEaseIn:
return(EaseInSine);
case EasingType.SineEaseInOut:
return(EaseInOutSine);
case EasingType.SineEaseOut:
return(EaseOutSine);
case EasingType.Spring:
return(Spring);
}
throw new System.NotImplementedException();
}
public abstract INormalizedKeyFrameAnimationBuilder <T> ExpressionKeyFrame(
double progress,
string expression,
EasingType easingType,
EasingMode easingMode);
// Fallback with dynamic typing
public AniMator(System.Object sta, System.Object end, System.Object chg, float dur, float delay, AnimationEasingType eas, EasingType typ, AnimationDriveType d) {
startValue = sta;
endValue = end;
change = chg;
Setup(dur, delay, eas, typ, d);
}
private static float Ease(float t, EasingType ease)
{
return(Ease(t, ease, true));
}
public static Vector3 InterpConstantSpeed(Path pts, float t, EasingType ease, bool easeIn)
{
return(InterpConstantSpeed(pts, t, ease, easeIn, true));
}
public static double ValueAt(double initial, double end, double alpha, EasingType easing)
{
switch (easing)
{
default:
case EasingType.None:
case EasingType.Linear:
return((end * alpha) + (initial * (1 - alpha)));
case EasingType.QuadIn:
{
double factor = alpha * alpha;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuadOut:
{
double factor = (2 - alpha) * alpha;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuadInOut:
{
double mid = initial + (end - initial) / 2.0;
if (alpha <= 0.5)
{
return(ValueAt(initial, mid, alpha * 2, EasingType.QuadIn));
}
else
{
return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.QuadOut));
}
}
case EasingType.CubeIn:
{
double factor = alpha * alpha * alpha;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.CubeOut:
{
double factor = -(alpha - 1);
factor = -(factor * factor * factor) + 1;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.CubeInOut:
{
double mid = initial + (end - initial) / 2.0;
if (alpha <= 0.5)
{
return(ValueAt(initial, mid, alpha * 2, EasingType.CubeIn));
}
else
{
return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.CubeOut));
}
}
case EasingType.QuartIn:
{
double factor = alpha * alpha * alpha * alpha;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuartOut:
{
double factor = -(alpha - 1);
factor = 1 - (factor * factor * factor * factor);
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuartInOut:
{
double mid = initial + (end - initial) / 2.0;
if (alpha <= 0.5)
{
return(ValueAt(initial, mid, alpha * 2, EasingType.QuartIn));
}
else
{
return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.QuartOut));
}
}
case EasingType.QuintIn:
{
double factor = alpha * alpha * alpha * alpha * alpha;
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuintOut:
{
double factor = -(alpha - 1);
factor = 1 - (factor * factor * factor * factor * factor);
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.QuintInOut:
{
double mid = initial + (end - initial) / 2.0;
if (alpha <= 0.5)
{
return(ValueAt(initial, mid, alpha / 0.5, EasingType.QuintIn));
}
else
{
return(ValueAt(mid, end, (alpha - 0.5) / 0.5, EasingType.QuintOut));
}
}
case EasingType.SineIn:
{
double factor = 1 - Math.Cos(Math.PI / 2 * alpha);
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.SineOut:
{
double factor = Math.Sin(Math.PI / 2 * alpha);
return((end * factor) + (initial * (1 - factor)));
}
case EasingType.SineInOut:
{
if (alpha <= 0.5)
{
return(ValueAt(initial, (initial + end) / 2.0, alpha * 2, EasingType.SineIn));
}
else
{
return(ValueAt((initial + end) / 2.0, end, (alpha - 0.5) * 2, EasingType.SineOut));
}
}
}
}
public static float EaseInOut ( double linearStep, EasingType easeInType, EasingType easeOutType )
{
return linearStep < 0.5 ? EaseInOut ( linearStep, easeInType ) : EaseInOut ( linearStep, easeOutType );
}
public static Quaternion RotationBetween(Spline.Path pts, float t1, float t2, EasingType ease, bool easeIn)
{
return Spline.RotationBetween(pts, t1, t2, ease, easeIn, true);
}
public static float EaseInOut(double linearStep, EasingType easeInType, EasingType easeOutType)
{
linearStep = Mathf.Clamp01((float)linearStep);
return linearStep < 0.5 ? EaseInOut(linearStep, easeInType) : EaseInOut(linearStep, easeOutType);
}
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn)
{
Spline.GizmoDraw(pts, t, ease, easeIn, true);
}
private static float Ease(float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
t = Mathf.Clamp01(t);
if(easeIn && easeOut)
{
t = Easing.EaseInOut(t, ease);
} else if(easeIn)
{
t = Easing.EaseIn(t, ease);
} else if(easeOut)
{
t = Easing.EaseOut(t, ease);
}
return t;
}
/// <summary>
/// Returns the output of an easing function for a specific time.
/// </summary>
/// <param name="t">The normalized time</param>
/// <param name="easingType">The easing function to use</param>
/// <returns>The eased output</returns>
public static float Ease(float t, EasingType easingType)
{
switch (easingType)
{
case EasingType.ExponentialIn: return(Functions.ExponentialIn(t));
case EasingType.ExponentialOut: return(Functions.ExponentialOut(t));
case EasingType.ExponentialInOut: return(Functions.ExponentialInOut(t));
case EasingType.ExponentialOutIn: return(Functions.ExponentialOutIn(t));
case EasingType.SineIn: return(Functions.SineIn(t));
case EasingType.SineOut: return(Functions.SineOut(t));
case EasingType.SineInOut: return(Functions.SineInOut(t));
case EasingType.SineOutIn: return(Functions.SineOutIn(t));
case EasingType.CubicIn: return(Functions.CubicIn(t));
case EasingType.CubicOut: return(Functions.CubicOut(t));
case EasingType.CubicInOut: return(Functions.CubicInOut(t));
case EasingType.CubicOutIn: return(Functions.CubicOutIn(t));
case EasingType.QuinticIn: return(Functions.QuinticIn(t));
case EasingType.QuinticOut: return(Functions.QuinticOut(t));
case EasingType.QuinticInOut: return(Functions.QuinticInOut(t));
case EasingType.QuinticOutIn: return(Functions.QuinticOutIn(t));
case EasingType.CircularIn: return(Functions.CircularIn(t));
case EasingType.CircularOut: return(Functions.CircularOut(t));
case EasingType.CircularInOut: return(Functions.CircularInOut(t));
case EasingType.CircularOutIn: return(Functions.CircularOutIn(t));
case EasingType.ElasticIn: return(Functions.ElasticIn(t));
case EasingType.ElasticOut: return(Functions.ElasticOut(t));
case EasingType.ElasticInOut: return(Functions.ElasticInOut(t));
case EasingType.ElasticOutIn: return(Functions.ElasticOutIn(t));
case EasingType.QuadraticIn: return(Functions.QuadraticIn(t));
case EasingType.QuadraticOut: return(Functions.QuadraticOut(t));
case EasingType.QuadraticInOut: return(Functions.QuadraticInOut(t));
case EasingType.QuadraticOutIn: return(Functions.QuadraticOutIn(t));
case EasingType.QuarticIn: return(Functions.QuarticIn(t));
case EasingType.QuarticOut: return(Functions.QuarticOut(t));
case EasingType.QuarticInOut: return(Functions.QuarticInOut(t));
case EasingType.QuarticOutIn: return(Functions.QuarticOutIn(t));
case EasingType.BackIn: return(Functions.BackIn(t));
case EasingType.BackOut: return(Functions.BackOut(t));
case EasingType.BackInOut: return(Functions.BackInOut(t));
case EasingType.BackOutIn: return(Functions.BackOutIn(t));
case EasingType.BounceIn: return(Functions.BounceIn(t));
case EasingType.BounceOut: return(Functions.BounceOut(t));
case EasingType.BounceInOut: return(Functions.BounceInOut(t));
case EasingType.BounceOutIn: return(Functions.BounceOutIn(t));
default: return(Functions.Linear(t));
}
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
var result = MoveOnPath(pts, currentPosition, ref pathPosition, maxSpeed, smoothnessFactor, ease, easeIn, easeOut);
rotation = result.Equals(currentPosition) ? Quaternion.identity : Quaternion.LookRotation(result - currentPosition);
return result;
}
private static float Ease(float t, EasingType ease, bool easeIn)
{
return Spline.Ease(t, ease, easeIn, true);
}
public static Vector3 Velocity(Path pts, float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
t = Ease(t);
if(pts.Length == 0)
{
return Vector3.zero;
}
else if(pts.Length ==1 )
{
return pts[0];
}
else if(pts.Length == 2)
{
return Vector3.Lerp(pts[0], pts[1], t);
}
else if(pts.Length == 3)
{
return QuadBez.Velocity(pts[0], pts[2], pts[1], t);
}
else if(pts.Length == 4)
{
return CubicBez.Velocity(pts[0], pts[3], pts[1], pts[2], t);
}
else
{
return CRSpline.Velocity(Wrap(pts), t);
}
}
public static Vector3 Interp(Spline.Path pts, float t, EasingType ease)
{
return Spline.Interp(pts, t, ease, true);
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn)
{
return(MoveOnPath(pts, currentPosition, ref pathPosition, ref rotation, maxSpeed, smoothnessFactor, ease, easeIn, true));
}
public static Vector3 InterpConstantSpeed(Spline.Path pts, float t, EasingType ease, bool easeIn)
{
return Spline.InterpConstantSpeed(pts, t, ease, easeIn, true);
}
/// <summary>
/// Animates the scale of the the specified UIElement.
/// </summary>
/// <param name="animationSet">The animationSet object.</param>
/// <param name="scaleX">The scale on the x axis.</param>
/// <param name="scaleY">The scale on the y axis.</param>
/// <param name="centerX">The center x in pixels.</param>
/// <param name="centerY">The center y in pixels.</param>
/// <param name="duration">The duration in milliseconds.</param>
/// <param name="delay">The delay in milliseconds. (ignored if duration == 0)</param>
/// <param name="easingType">Used to describe how the animation interpolates between keyframes.</param>
/// <returns>
/// An AnimationSet.
/// </returns>
public static AnimationSet Scale(
this AnimationSet animationSet,
float scaleX = 1f,
float scaleY = 1f,
float centerX = 0f,
float centerY = 0f,
double duration = 500d,
double delay = 0d,
EasingType easingType = EasingType.Default)
{
if (animationSet == null)
{
return(null);
}
if (!AnimationSet.UseComposition)
{
var element = animationSet.Element;
var transform = GetAttachedCompositeTransform(element);
transform.CenterX = centerX;
transform.CenterY = centerY;
var animationX = new DoubleAnimation();
var animationY = new DoubleAnimation();
animationX.To = scaleX;
animationY.To = scaleY;
animationX.Duration = animationY.Duration = TimeSpan.FromMilliseconds(duration);
animationX.BeginTime = animationY.BeginTime = TimeSpan.FromMilliseconds(delay);
animationX.EasingFunction = animationY.EasingFunction = GetEasingFunction(easingType);
animationSet.AddStoryboardAnimation(GetAnimationPath(transform, element, "ScaleX"), animationX);
animationSet.AddStoryboardAnimation(GetAnimationPath(transform, element, "ScaleY"), animationY);
}
else
{
var visual = animationSet.Visual;
visual.CenterPoint = new Vector3(centerX, centerY, 0);
var scaleVector = new Vector3(scaleX, scaleY, 1.0f);
if (duration <= 0)
{
animationSet.AddCompositionDirectPropertyChange("Scale", scaleVector);
return(animationSet);
}
var compositor = visual.Compositor;
if (compositor == null)
{
return(null);
}
var animation = compositor.CreateVector3KeyFrameAnimation();
animation.Duration = TimeSpan.FromMilliseconds(duration);
animation.DelayTime = TimeSpan.FromMilliseconds(delay);
animation.InsertKeyFrame(1f, scaleVector);
animationSet.AddCompositionAnimation("Scale", animation);
}
return(animationSet);
}
public static float EaseWithReturn(double linearStep, EasingType ease)
{
linearStep = (double)Mathf.Clamp01((float)linearStep);
var amount = linearStep > 0.5 ? 1+((0.5-linearStep)*2) : (linearStep * 2);
return EaseOut(amount, ease);
}
public static EasingEquation GetEquation(EasingType type)
{
switch (type)
{
case EasingType.Linear:
return(Easing.Linear);
case EasingType.EaseInQuad:
return(Easing.EaseInQuad);
case EasingType.EaseOutQuad:
return(Easing.EaseOutQuad);
case EasingType.EaseInOutQuad:
return(Easing.EaseInOutQuad);
case EasingType.EaseOutInQuad:
return(Easing.EaseOutInQuad);
case EasingType.EaseInCubic:
return(Easing.EaseInCubic);
case EasingType.EaseOutCubic:
return(Easing.EaseOutCubic);
case EasingType.EaseInOutCubic:
return(Easing.EaseInOutCubic);
case EasingType.EaseOutInCubic:
return(Easing.EaseOutInCubic);
case EasingType.EaseInQuart:
return(Easing.EaseInQuart);
case EasingType.EaseOutQuart:
return(Easing.EaseOutQuart);
case EasingType.EaseInOutQuart:
return(Easing.EaseInOutQuart);
case EasingType.EaseOutInQuart:
return(Easing.EaseOutInQuart);
case EasingType.EaseInQuint:
return(Easing.EaseInQuint);
case EasingType.EaseOutQuint:
return(Easing.EaseOutQuint);
case EasingType.EaseInOutQuint:
return(Easing.EaseInOutQuint);
case EasingType.EaseOutInQuint:
return(Easing.EaseOutInQuint);
case EasingType.EaseInSine:
return(Easing.EaseInSine);
case EasingType.EaseOutSine:
return(Easing.EaseOutSine);
case EasingType.EaseInOutSine:
return(Easing.EaseInOutSine);
case EasingType.EaseOutInSine:
return(Easing.EaseOutInSine);
case EasingType.EaseInExpo:
return(Easing.EaseInExpo);
case EasingType.EaseOutExpo:
return(Easing.EaseOutExpo);
case EasingType.EaseInOutExpo:
return(Easing.EaseInOutExpo);
case EasingType.EaseOutInExpo:
return(Easing.EaseOutInExpo);
case EasingType.EaseInCirc:
return(Easing.EaseInCirc);
case EasingType.EaseOutCirc:
return(Easing.EaseOutCirc);
case EasingType.EaseInOutCirc:
return(Easing.EaseInOutCirc);
case EasingType.EaseOutInCirc:
return(Easing.EaseOutInCirc);
case EasingType.EaseInBack:
return(Easing.EaseInBack);
case EasingType.EaseOutBack:
return(Easing.EaseOutBack);
case EasingType.EaseInOutBack:
return(Easing.EaseInOutBack);
case EasingType.EaseOutInBack:
return(Easing.EaseOutInBack);
case EasingType.EaseInElastic:
return(Easing.EaseInElastic);
case EasingType.EaseOutElastic:
return(Easing.EaseOutElastic);
case EasingType.EaseInOutElastic:
return(Easing.EaseInOutElastic);
case EasingType.EaseOutInElastic:
return(Easing.EaseOutInElastic);
case EasingType.EaseInBounce:
return(Easing.EaseInBounce);
case EasingType.EaseOutBounce:
return(Easing.EaseOutBounce);
case EasingType.EaseInOutBounce:
return(Easing.EaseInOutBounce);
case EasingType.EaseOutInBounce:
return(Easing.EaseOutInBounce);
default:
return(null);
}
}
public override void Vibrate(VibrationMotor motor, double amount, float duration, EasingType easingType)
{
throw new NotSupportedException();
}
protected virtual async UniTask ApplyAppearanceModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(AssignedAppearance))
{
return;
}
var transitionName = !string.IsNullOrEmpty(AssignedTransition) ? AssignedTransition : TransitionType.Crossfade;
var defaultParams = TransitionUtils.GetDefaultParams(transitionName);
var transitionParams = Assigned(TransitionParams) ? new Vector4(
TransitionParams.ElementAtOrNull(0) ?? defaultParams.x,
TransitionParams.ElementAtOrNull(1) ?? defaultParams.y,
TransitionParams.ElementAtOrNull(2) ?? defaultParams.z,
TransitionParams.ElementAtOrNull(3) ?? defaultParams.w) : defaultParams;
if (Assigned(DissolveTexturePath) && !ObjectUtils.IsValid(preloadedDissolveTexture))
{
preloadedDissolveTexture = Resources.Load <Texture2D>(DissolveTexturePath);
}
var transition = new Transition(transitionName, transitionParams, preloadedDissolveTexture);
await actor.ChangeAppearanceAsync(AssignedAppearance, duration, easingType, transition, cancellationToken);
}
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
maxSpeed *= Time.deltaTime;
pathPosition = Mathf.Clamp01(pathPosition);
var goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
float distance;
while((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition < 1)
{
currentPosition = goal;
maxSpeed -= distance;
pathPosition = Mathf.Clamp01(pathPosition + 1/smoothnessFactor);
goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
}
if(distance != 0)
{
currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed);
}
return currentPosition;
}
protected virtual async UniTask ApplyVisibilityModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken)
{
if (!AssignedVisibility.HasValue)
{
return;
}
await actor.ChangeVisibilityAsync(AssignedVisibility.Value, duration, easingType, cancellationToken);
}
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
{
return Quaternion.LookRotation(Interp(pts, t2, ease, easeIn, easeOut) - Interp(pts, t1, ease, easeIn, easeOut));
}
protected virtual async UniTask ApplyTintColorModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken)
{
if (!AssignedTintColor.HasValue)
{
return;
}
await actor.ChangeTintColorAsync(AssignedTintColor.Value, duration, easingType, cancellationToken);
}
public static void GizmoDraw(Vector3[] pts, float t,EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) {
Gizmos.color = Color.white;
Vector3 prevPt = Interp(pts, 0);
for (int i = 1; i <= 20; i++) {
float pm = (float) i / 20f;
Vector3 currPt = Interp(pts, pm, ease, easeIn, easeOut);
Gizmos.DrawLine(currPt, prevPt);
prevPt = currPt;
}
Gizmos.color = Color.blue;
Vector3 pos = Interp(pts, t, ease, easeIn, easeOut);
Gizmos.DrawLine(pos, pos + Velocity(pts, t, ease, easeIn, easeOut));
}
public static float EaseInOut(double linearStep, EasingType easeInType, EasingType easeOutType)
{
return(linearStep < 0.5 ? EaseInOut(linearStep, easeInType) : EaseInOut(linearStep, easeOutType));
}
