MoonsideGames
/
MoonTools.Easing
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

back functions

master
Evan Hemsley 2019-10-30 19:57:00 -07:00
parent 87505e197b
commit d7e49ead3e
2 changed files with 327 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
Easing/Easing.cs
View File

@ -602,11 +602,12 @@ namespace MoonTools.Core.Easing
public static double OutInCirc(double time, double start, double end) => TimeRange(OutInCirc, time, start, end);
public static double OutInCirc(double t, double b, double c, double d) => OutIn(OutCirc, InCirc, t, b, c, d);
// IN ELASTIC
// ELASTIC functions have two optional extra arguments
// a: amplitude
// p: period
// IN ELASTIC
public static double InElasticNormalized(double t) => InElastic(t, 0, 1, 1);
public static double InElasticNormalized(double t, double a) => InElastic(t, 0, 1, 1, a);
public static double InElasticNormalized(double t, double a, double p) => InElastic(t, 0, 1, 1, a, p);
@ -679,5 +680,147 @@ namespace MoonTools.Core.Easing
return a.Value * Math.Pow(2, -10 * t) * Math.Sin((t * d - s) * (2 * Math.PI) / p.Value) + c + b;
}
// IN OUT ELASTIC
public static double InOutElasticNormalized(double t) => InOutElastic(t, 0, 1, 1);
public static double InOutElasticNormalized(double t, double a) => InOutElastic(t, 0, 1, 1, a);
public static double InOutElasticNormalized(double t, double a, double p) => InOutElastic(t, 0, 1, 1, a, p);
public static double InOutElasticTimeRange(double time, double start, double end) => start + (end - start) * InOutElasticNormalized((time - start) / (end - start));
public static double InOutElasticTimeRange(double time, double start, double end, double a) => start + (end - start) * InOutElasticNormalized((time - start) / (end - start), a);
public static double InOutElasticTimeRange(double time, double start, double end, double a, double p) => start + (end - start) * InOutElasticNormalized((time - start) / (end - start), a, p);
public static double InOutElastic(double t, double b, double c, double d, double? a = null, double? p = null)
{
CheckTime(t, d);
if (t == 0) { return b; }
t = t / d * 2;
if (t == 2) { return b + c; }
if (!p.HasValue) { p = d * (0.3 * 1.5); }
if (!a.HasValue) { a = 0; }
double s;
if (!a.HasValue || a < Math.Abs(c))
{
a = c;
s = p.Value / 4;
}
else
{
s = p.Value / (2 * Math.PI) * Math.Asin(c / a.Value);
}
if (t < 1)
{
t = t - 1;
return -0.5 * (a.Value * Math.Pow(2, 10 * t) * Math.Sin((t * d - s) * (2 * Math.PI) / p.Value)) + b;
}
else
{
t = t - 1;
return a.Value * Math.Pow(2, -10 * t) * Math.Sin((t * d - s) * (2 * Math.PI) / p.Value) * 0.5 + c + b;
}
}
// OUT IN ELASTIC
public static double OutInElasticNormalized(double t) => OutInElastic(t, 0, 1, 1);
public static double OutInElasticNormalized(double t, double a) => OutInElastic(t, 0, 1, 1, a);
public static double OutInElasticNormalized(double t, double a, double p) => OutInElastic(t, 0, 1, 1, a, p);
public static double OutInElasticTimeRange(double time, double start, double end) => start + (end - start) * OutInElasticNormalized((time - start) / (end - start));
public static double OutInElasticTimeRange(double time, double start, double end, double a) => start + (end - start) * OutInElasticNormalized((time - start) / (end - start), a);
public static double OutInElasticTimeRange(double time, double start, double end, double a, double p) => start + (end - start) * OutInElasticNormalized((time - start) / (end - start), a, p);
public static double OutInElastic(double t, double b, double c, double d, double? a = null, double? p = null)
{
if (t < d / 2)
{
return OutElastic(t * 2, b, c / 2, d, a, p);
}
else
{
return InElastic((t * 2) - d, b + c / 2, c / 2, d, a, p);
}
}
// back functions take an optional parameter
// s: size
// IN BACK
public static double InBackNormalized(double t) => InBack(t, 0, 1, 1);
public static double InBackNormalized(double t, double s) => InBack(t, 0, 1, 1, s);
public static double InBackTimeRange(double time, double start, double end) => start + (end - start) * InBackNormalized((time - start) / (end - start));
public static double InBackTimeRange(double time, double start, double end, double s) => start + (end - start) * InBackNormalized((time - start) / (end - start), s);
public static double InBack(double t, double b, double c, double d, double s = 1.70158)
{
CheckTime(t, d);
t = t / d;
return c * t * t * ((s + 1) * t - s) + b;
}
// OUT BACK
public static double OutBackNormalized(double t) => OutBack(t, 0, 1, 1);
public static double OutBackNormalized(double t, double s) => OutBack(t, 0, 1, 1, s);
public static double OutBackTimeRange(double time, double start, double end) => start + (end - start) * OutBackNormalized((time - start) / (end - start));
public static double OutBackTimeRange(double time, double start, double end, double s) => start + (end - start) * OutBackNormalized((time - start) / (end - start), s);
public static double OutBack(double t, double b, double c, double d, double s = 1.70158)
{
CheckTime(t, d);
t = t / d - 1;
return c * (t * t * ((s + 1) * t + s) + 1) + b;
}
// IN OUT BACK
public static double InOutBackNormalized(double t) => InOutBack(t, 0, 1, 1);
public static double InOutBackNormalized(double t, double s) => InOutBack(t, 0, 1, 1, s);
public static double InOutBackTimeRange(double time, double start, double end) => start + (end - start) * InOutBackNormalized((time - start) / (end - start));
public static double InOutBackTimeRange(double time, double start, double end, double s) => start + (end - start) * InOutBackNormalized((time - start) / (end - start), s);
public static double InOutBack(double t, double b, double c, double d, double s = 1.70158)
{
CheckTime(t, d);
s = s * 1.525;
t = t / d * 2;
if (t < 1)
{
return c / 2 * (t * t * ((s + 1) * t - s)) + b;
}
else
{
t = t - 2;
return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b;
}
}
// OUT IN BACK
public static double OutInBackNormalized(double t) => OutInBack(t, 0, 1, 1);
public static double OutInBackNormalized(double t, double s) => OutInBack(t, 0, 1, 1, s);
public static double OutInBackTimeRange(double time, double start, double end) => start + (end - start) * OutInBackNormalized((time - start) / (end - start));
public static double OutInBackTimeRange(double time, double start, double end, double s) => start + (end - start) * OutInBackNormalized((time - start) / (end - start), s);
public static double OutInBack(double t, double b, double c, double d, double s = 1.70158)
{
if (t < d / 2)
{
return OutBack(t * 2, b, c / 2, d, s);
}
else
{
return InBack((t * 2) - d, b + c / 2, c / 2, d, s);
}
}
}
}

184
Test/Easing.cs
View File

@ -902,7 +902,7 @@ namespace Test
Easing.InElasticTimeRange(4, 2, 6).Should().BeApproximately(1.9375, 0.001);
Easing.InElasticTimeRange(5, 2, 6).Should().BeApproximately(2.35355339059, 0.001);
CheckDoubleArguments(Easing.InElasticNormalized, Easing.InElasticNormalized);
CheckDoubleArguments(Easing.InElasticNormalized, Easing.InElasticTimeRange);
}
[Test]
@ -940,7 +940,7 @@ namespace Test
Easing.OutElasticTimeRange(4, 2, 6).Should().BeApproximately(6.0625, 0.001);
Easing.OutElasticTimeRange(5, 2, 6).Should().BeApproximately(6.02209708691, 0.001);
CheckDoubleArguments(Easing.OutElasticNormalized, Easing.OutElasticNormalized);
CheckDoubleArguments(Easing.OutElasticNormalized, Easing.OutElasticTimeRange);
}
[Test]
@ -966,6 +966,186 @@ namespace Test
Easing.OutElasticTimeRange(4, 2, 6, 10, 0.5).Should().BeApproximately(5.875, 0.001);
Easing.OutElasticTimeRange(5, 2, 6, 10, 0.5).Should().BeApproximately(6.02209708691, 0.001);
}
[Test]
public void InOutElasticDefault()
{
Easing.InOutElasticNormalized(0.25).Should().BeApproximately(0.011969444423734, 0.001);
Easing.InOutElasticNormalized(0.5).Should().BeApproximately(0.5, 0.001);
Easing.InOutElasticNormalized(0.75).Should().BeApproximately(0.98803055557627, 0.001);
Easing.InOutElasticTimeRange(3, 2, 6).Should().BeApproximately(2.0478777777, 0.001);
Easing.InOutElasticTimeRange(4, 2, 6).Should().BeApproximately(4, 0.001);
Easing.InOutElasticTimeRange(5, 2, 6).Should().BeApproximately(5.9521222223, 0.001);
CheckDoubleArguments(Easing.InOutElasticNormalized, Easing.InOutElasticTimeRange);
}
[Test]
public void InOutElasticWithA()
{
Easing.InOutElasticNormalized(0.25, 10).Should().BeApproximately(0.11190156885591, 0.001);
Easing.InOutElasticNormalized(0.5, 10).Should().BeApproximately(0.5, 0.001);
Easing.InOutElasticNormalized(0.75, 10).Should().BeApproximately(1.0879626800084, 0.001);
Easing.InOutElasticTimeRange(3, 2, 6, 10).Should().BeApproximately(2.44760627542, 0.001);
Easing.InOutElasticTimeRange(4, 2, 6, 10).Should().BeApproximately(4, 0.001);
Easing.InOutElasticTimeRange(5, 2, 6, 10).Should().BeApproximately(6.35185072004, 0.001);
}
[Test]
public void InOutElasticWithAAndP()
{
Easing.InOutElasticNormalized(0.25, 10, 0.5).Should().BeApproximately(0.015625, 0.001);
Easing.InOutElasticNormalized(0.5, 10, 0.5).Should().BeApproximately(0.5, 0.001);
Easing.InOutElasticNormalized(0.75, 10, 0.5).Should().BeApproximately(0.984375, 0.001);
Easing.InOutElasticTimeRange(3, 2, 6, 10, 0.5).Should().BeApproximately(2.0625, 0.001);
Easing.InOutElasticTimeRange(4, 2, 6, 10, 0.5).Should().BeApproximately(4, 0.001);
Easing.InOutElasticTimeRange(5, 2, 6, 10, 0.5).Should().BeApproximately(5.9375, 0.001);
}
[Test]
public void OutInElasticDefault()
{
Easing.OutInElasticNormalized(0.25).Should().BeApproximately(0.5078125, 0.001);
Easing.OutInElasticNormalized(0.5).Should().BeApproximately(0.5, 0.001);
Easing.OutInElasticNormalized(0.75).Should().BeApproximately(0.4921875, 0.001);
Easing.OutInElasticTimeRange(3, 2, 6).Should().BeApproximately(4.03125, 0.001);
Easing.OutInElasticTimeRange(4, 2, 6).Should().BeApproximately(4, 0.001);
Easing.OutInElasticTimeRange(5, 2, 6).Should().BeApproximately(3.96875, 0.001);
CheckDoubleArguments(Easing.OutInElasticNormalized, Easing.OutInElasticTimeRange);
}
[Test]
public void OutInElasticWithA()
{
Easing.OutInElasticNormalized(0.25, 10).Should().BeApproximately(0.2375180641874, 0.001);
Easing.OutInElasticNormalized(0.5, 10).Should().BeApproximately(0.5, 0.001);
Easing.OutInElasticNormalized(0.75, 10).Should().BeApproximately(0.2218930641874, 0.001);
Easing.OutInElasticTimeRange(3, 2, 6, 10).Should().BeApproximately(2.95007225675, 0.001);
Easing.OutInElasticTimeRange(4, 2, 6, 10).Should().BeApproximately(4, 0.001);
Easing.OutInElasticTimeRange(5, 2, 6, 10).Should().BeApproximately(2.88757225675, 0.001);
}
[Test]
public void OutInElasticWithAAndP()
{
Easing.OutInElasticNormalized(0.25, 10, 0.5).Should().BeApproximately(0.484375, 0.001);
Easing.OutInElasticNormalized(0.5, 10, 0.5).Should().BeApproximately(0.5, 0.001);
Easing.OutInElasticNormalized(0.75, 10, 0.5).Should().BeApproximately(0.515625, 0.001);
Easing.OutInElasticTimeRange(3, 2, 6, 10, 0.5).Should().BeApproximately(3.9375, 0.001);
Easing.OutInElasticTimeRange(4, 2, 6, 10, 0.5).Should().BeApproximately(4, 0.001);
Easing.OutInElasticTimeRange(5, 2, 6, 10, 0.5).Should().BeApproximately(4.0625, 0.001);
}
[Test]
public void InBackDefault()
{
Easing.InBackNormalized(0.25).Should().BeApproximately(-0.0641365625, 0.001);
Easing.InBackNormalized(0.5).Should().BeApproximately(-0.0876975, 0.001);
Easing.InBackNormalized(0.75).Should().BeApproximately(0.1825903125, 0.001);
Easing.InBackTimeRange(3, 2, 6).Should().BeApproximately(1.74345375, 0.001);
Easing.InBackTimeRange(4, 2, 6).Should().BeApproximately(1.64921, 0.001);
Easing.InBackTimeRange(5, 2, 6).Should().BeApproximately(2.73036125, 0.001);
CheckDoubleArguments(Easing.InBackNormalized, Easing.InBackTimeRange);
}
[Test]
public void InBackWithSize()
{
Easing.InBackNormalized(0.25, 3).Should().BeApproximately(-0.125, 0.001);
Easing.InBackNormalized(0.5, 3).Should().BeApproximately(-0.25, 0.001);
Easing.InBackNormalized(0.75, 3).Should().BeApproximately(0, 0.001);
Easing.InBackTimeRange(3, 2, 6, 3).Should().BeApproximately(1.5, 0.001);
Easing.InBackTimeRange(4, 2, 6, 3).Should().BeApproximately(1, 0.001);
Easing.InBackTimeRange(5, 2, 6, 3).Should().BeApproximately(2, 0.001);
}
[Test]
public void OutBackDefault()
{
Easing.OutBackNormalized(0.25).Should().BeApproximately(0.8174096875, 0.001);
Easing.OutBackNormalized(0.5).Should().BeApproximately(1.0876975, 0.001);
Easing.OutBackNormalized(0.75).Should().BeApproximately(1.0641365625, 0.001);
Easing.OutBackTimeRange(3, 2, 6).Should().BeApproximately(5.26963875, 0.001);
Easing.OutBackTimeRange(4, 2, 6).Should().BeApproximately(6.35079, 0.001);
Easing.OutBackTimeRange(5, 2, 6).Should().BeApproximately(6.25654625, 0.001);
CheckDoubleArguments(Easing.OutBackNormalized, Easing.OutBackTimeRange);
}
[Test]
public void OutBackWithSize()
{
Easing.OutBackNormalized(0.25, 3).Should().BeApproximately(1, 0.001);
Easing.OutBackNormalized(0.5, 3).Should().BeApproximately(1.25, 0.001);
Easing.OutBackNormalized(0.75, 3).Should().BeApproximately(1.125, 0.001);
Easing.OutBackTimeRange(3, 2, 6, 3).Should().BeApproximately(6, 0.001);
Easing.OutBackTimeRange(4, 2, 6, 3).Should().BeApproximately(7, 0.001);
Easing.OutBackTimeRange(5, 2, 6, 3).Should().BeApproximately(6.5, 0.001);
}
[Test]
public void InOutBackDefault()
{
Easing.InOutBackNormalized(0.25).Should().BeApproximately(-0.09968184375, 0.001);
Easing.InOutBackNormalized(0.5).Should().BeApproximately(0.5, 0.001);
Easing.InOutBackNormalized(0.75).Should().BeApproximately(1.09968184375, 0.001);
Easing.InOutBackTimeRange(3, 2, 6).Should().BeApproximately(1.601272625, 0.001);
Easing.InOutBackTimeRange(4, 2, 6).Should().BeApproximately(4, 0.001);
Easing.InOutBackTimeRange(5, 2, 6).Should().BeApproximately(6.398727375, 0.001);
CheckDoubleArguments(Easing.InOutBackNormalized, Easing.InOutBackTimeRange);
}
[Test]
public void InOutBackWithSize()
{
Easing.InOutBackNormalized(0.25, 3).Should().BeApproximately(-0.2234375, 0.001);
Easing.InOutBackNormalized(0.5, 3).Should().BeApproximately(0.5, 0.001);
Easing.InOutBackNormalized(0.75, 3).Should().BeApproximately(1.2234375, 0.001);
Easing.InOutBackTimeRange(3, 2, 6, 3).Should().BeApproximately(1.10625, 0.001);
Easing.InOutBackTimeRange(4, 2, 6, 3).Should().BeApproximately(4, 0.001);
Easing.InOutBackTimeRange(5, 2, 6, 3).Should().BeApproximately(6.89375, 0.001);
}
[Test]
public void OutInBackDefault()
{
Easing.OutInBackNormalized(0.25).Should().BeApproximately(0.54384875, 0.001);
Easing.OutInBackNormalized(0.5).Should().BeApproximately(0.5, 0.001);
Easing.OutInBackNormalized(0.75).Should().BeApproximately(0.45615125, 0.001);
Easing.OutInBackTimeRange(3, 2, 6).Should().BeApproximately(4.175395, 0.001);
Easing.OutInBackTimeRange(4, 2, 6).Should().BeApproximately(4, 0.001);
Easing.OutInBackTimeRange(5, 2, 6).Should().BeApproximately(3.824605, 0.001);
CheckDoubleArguments(Easing.OutInBackNormalized, Easing.OutInBackTimeRange);
}
[Test]
public void OutInBackWithSize()
{
Easing.OutInBackNormalized(0.25, 3).Should().BeApproximately(0.625, 0.001);
Easing.OutInBackNormalized(0.5, 3).Should().BeApproximately(0.5, 0.001);
Easing.OutInBackNormalized(0.75, 3).Should().BeApproximately(0.375, 0.001);
Easing.OutInBackTimeRange(3, 2, 6, 3).Should().BeApproximately(4.5, 0.001);
Easing.OutInBackTimeRange(4, 2, 6, 3).Should().BeApproximately(4, 0.001);
Easing.OutInBackTimeRange(5, 2, 6, 3).Should().BeApproximately(3.5, 0.001);
}
}
}
}