あまりにも多すぎるので、私のプロジェクトでの戦略実装なので、この 30 種類ほどは本当に古い血を吐き出しています。
同様の必要がある場合は、テキスト置換を使用して既製のものを直接使用することをお勧めします (古い血をもう一口吐き出します)
曲面界面
public interface ICurve
{
// 0 <= x <= 1
public float Evaluate(float x);
}
カーブの取り方
public class BuiltInCurve
{
public static ICurve GetCurve(EaseCurve curveType)
{
switch (curveType)
{
case EaseCurve.Linear:
return LinearCurve.Instance;
case EaseCurve.InSine:
return InSineCurve.Instance;
case EaseCurve.OutSine:
return OutSineCurve.Instance;
case EaseCurve.InOutSine:
return InOutSineCurve.Instance;
case EaseCurve.InQuad:
return InQuadCurve.Instance;
case EaseCurve.OutQuad:
return OutQuadCurve.Instance;
case EaseCurve.InOutQuad:
return InOutQuadCurve.Instance;
case EaseCurve.InCubic:
return InCubicCurve.Instance;
case EaseCurve.OutCubic:
return OutCubicCurve.Instance;
case EaseCurve.InOutCubic:
return InOutCubicCurve.Instance;
case EaseCurve.InQuart:
return InQuartCurve.Instance;
case EaseCurve.OutQuart:
return OutQuartCurve.Instance;
case EaseCurve.InOutQuart:
return InOutQuartCurve.Instance;
case EaseCurve.InQuint:
return InQuintCurve.Instance;
case EaseCurve.OutQuint:
return OutQuintCurve.Instance;
case EaseCurve.InOutQuint:
return InOutQuintCurve.Instance;
case EaseCurve.InExpo:
return InExpoCurve.Instance;
case EaseCurve.OutExpo:
return OutExpoCurve.Instance;
case EaseCurve.InOutExpo:
return InOutExpoCurve.Instance;
case EaseCurve.InCirc:
return InCircCurve.Instance;
case EaseCurve.OutCirc:
return OutCircCurve.Instance;
case EaseCurve.InOutCirc:
return InOutCircCurve.Instance;
case EaseCurve.InBack:
return InBackCurve.Instance;
case EaseCurve.OutBack:
return OutBackCurve.Instance;
case EaseCurve.InOutBack:
return InOutBackCurve.Instance;
case EaseCurve.InBounce:
return InBounceCurve.Instance;
case EaseCurve.OutBounce:
return OutBounceCurve.Instance;
case EaseCurve.InOutBounce:
return InOutBounceCurve.Instance;
case EaseCurve.InElastic:
return InElasticCurve.Instance;
case EaseCurve.OutElastic:
return OutElasticCurve.Instance;
case EaseCurve.InOutElastic:
return InOutElasticCurve.Instance;
default:
throw new ArgumentException("Invalid EaseCurve value", "curveType");
}
}
}
曲線の列挙
namespace AirFramework
{
public enum EaseCurve
{
Linear, // 线性缓动，匀速运动
InSine, // 正弦加速缓动，开始缓慢，后来加速
OutSine, // 正弦减速缓动，开始快速，后来减速
InOutSine, // 正弦波缓动，先加速后减速
InQuad, // 二次方加速缓动，开始缓慢，后来加速
OutQuad, // 二次方减速缓动，开始快速，后来减速
InOutQuad, // 二次方波缓动，先加速后减速
InCubic, // 三次方加速缓动，开始缓慢，后来加速
OutCubic, // 三次方减速缓动，开始快速，后来减速
InOutCubic, // 三次方波缓动，先加速后减速
InQuart, // 四次方加速缓动，开始缓慢，后来加速
OutQuart, // 四次方减速缓动，开始快速，后来减速
InOutQuart, // 四次方波缓动，先加速后减速
InQuint, // 五次方加速缓动，开始缓慢，后来加速
OutQuint, // 五次方减速缓动，开始快速，后来减速
InOutQuint, // 五次方波缓动，先加速后减速
InExpo, // 指数加速缓动，开始缓慢，后来加速
OutExpo, // 指数减速缓动，开始快速，后来减速
InOutExpo, // 指数波缓动，先加速后减速
InCirc, // 圆形加速缓动，开始缓慢，后来加速
OutCirc, // 圆形减速缓动，开始快速，后来减速
InOutCirc, // 圆形波缓动，先加速后减速
InOutBack, // 先正弦减速后正弦加速缓动，开始快速，后来减速，再加速
InBack, // 回退加速（类似弹簧），开始缓慢，后来加速并回退一定距离，然后减速回弹
OutBack, // 回退减速（类似弹簧），开始快速，后来减速并回退一定距离，然后加速回
InBounce, // 弹跳加速缓动，开始缓慢，后来加速并反弹
OutBounce, // 弹跳减速缓动，开始快速，后来减速并反弹
InOutBounce, // 弹跳波缓动，先加速后减速并反弹
InElastic, // 弹性加速缓动，开始缓慢，后来加速并弹性拉伸
OutElastic, // 弹性减速缓动，开始快速，后来减速并弹性拉伸
InOutElastic, // 弹性波缓动，先加速后减速并弹性拉伸
}
}
以下は曲線の実装です
using System;
namespace AirFramework
{
#region Linear
public class LinearCurve : Singleton<LinearCurve>, ICurve
{
public float Evaluate(float x)
{
return x;
}
}
#endregion
#region Sine
public class InSineCurve : Singleton<InSineCurve>, ICurve
{
public float Evaluate(float x)
{
return -(float)Math.Cos((double)(x * 1.5707964f)) + 1f;
}
}
//2
public class OutSineCurve : Singleton<OutSineCurve>, ICurve
{
public float Evaluate(float x)
{
return (float)Math.Sin((double)(x * 1.5707964f));
}
}
//3
public class InOutSineCurve : Singleton<InOutSineCurve>, ICurve
{
public float Evaluate(float x)
{
return -0.5f * ((float)Math.Cos((double)(Math.PI * x)) - 1f);
}
}
#endregion
#region Quad
//4
public class InQuadCurve : Singleton<InQuadCurve>, ICurve
{
public float Evaluate(float x)
{
return x * x;
}
}
//5
public class OutQuadCurve : Singleton<OutQuadCurve>, ICurve
{
public float Evaluate(float x)
{
return 1f - (1f - x) * (1f - x);
}
}
//6
public class InOutQuadCurve : Singleton<InOutQuadCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f ? 2f * x * x : 1f - 2f * (1f - x) * (1f - x);
}
}
#endregion
#region Cubic
//7
public class InCubicCurve : Singleton<InCubicCurve>, ICurve
{
public float Evaluate(float x)
{
return x * x * x;
}
}
//8
public class OutCubicCurve : Singleton<OutCubicCurve>, ICurve
{
public float Evaluate(float x)
{
var t = x - 1f;
return t * t * t + 1f;
}
}
//9
public class InOutCubicCurve : Singleton<InOutCubicCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f ? 4f * x * x * x : 1f + 4f * (x - 1f) * (x - 1f) * (x - 1f);
}
}
#endregion
#region Quart
//10
public class InQuartCurve : Singleton<InQuartCurve>, ICurve
{
public float Evaluate(float x)
{
return x * x * x * x;
}
}
//11
public class OutQuartCurve : Singleton<OutQuartCurve>, ICurve
{
public float Evaluate(float x)
{
var t = x - 1f;
return 1f - t * t * t * t;
}
}
//12
public class InOutQuartCurve : Singleton<InOutQuartCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f ? 8f * x * x * x * x : 1f - 8f * (x - 1f) * (x - 1f) * (x - 1f) * (x - 1f);
}
}
#endregion
#region Quint
//13
public class InQuintCurve : Singleton<InQuintCurve>, ICurve
{
public float Evaluate(float x)
{
return x * x * x * x * x;
}
}
//14
public class OutQuintCurve : Singleton<OutQuintCurve>, ICurve
{
public float Evaluate(float x)
{
var t = x - 1f;
return t * t * t * t * t + 1f;
}
}
//15
public class InOutQuintCurve : Singleton<InOutQuintCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f ? 16f * x * x * x * x * x : 1f + 16f * (x - 1f) * (x - 1f) * (x - 1f) * (x - 1f) * (x - 1f);
}
}
#endregion
#region Expo
//16
public class InExpoCurve : Singleton<InExpoCurve>, ICurve
{
public float Evaluate(float x)
{
return x == 0f ? 0f : (float)Math.Pow(2f, 10f * (x - 1f));
}
}
//17
public class OutExpoCurve : Singleton<OutExpoCurve>, ICurve
{
public float Evaluate(float x)
{
return x == 1f ? 1f : -(float)Math.Pow(2f, -10f * x) + 1f;
}
}
//18
public class InOutExpoCurve : Singleton<InOutExpoCurve>, ICurve
{
public float Evaluate(float x)
{
if (x == 0f) return 0f;
if (x == 1f) return 1f;
return x < 0.5f ? 0.5f * (float)Math.Pow(2f, 10f * (2f * x - 1f)) : 0.5f * (-(float)Math.Pow(2f, -10f * (2f * x - 1f)) + 2f);
}
}
#endregion
#region Circ
public class InCircCurve : Singleton<InCircCurve>, ICurve
{
public float Evaluate(float x)
{
return 1f - (float)Math.Sqrt(1f - x * x);
}
}
//20
public class OutCircCurve : Singleton<OutCircCurve>, ICurve
{
public float Evaluate(float x)
{
return (float)Math.Sqrt(1f - (x - 1f) * (x - 1f));
}
}
//21
public class InOutCircCurve : Singleton<InOutCircCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f ? 0.5f * (1f - (float)Math.Sqrt(1f - 4f * x * x)) : 0.5f * ((float)Math.Sqrt(1f - 4f * (x - 1f) * (x - 1f)) + 1f);
}
}
#endregion
#region Back
//22
public class InBackCurve : Singleton<InBackCurve>, ICurve
{
private const float c1 = 1.70158f;
private const float c2 = c1 * 1.525f;
public float Evaluate(float x)
{
return c2 * x * x * x - c1 * x * x;
}
}
//23
public class OutBackCurve : Singleton<OutBackCurve>, ICurve
{
private const float c1 = 1.70158f;
private const float c2 = c1 * 1.525f;
public float Evaluate(float x)
{
var t = x - 1f;
return t * t;
}
}
//27
public class InOutBackCurve : Singleton<InOutBackCurve>, ICurve
{
public float Evaluate(float x)
{
const float c1 = 1.70158f;
const float c2 = c1 * 1.525f;
return (float)(x < 0.5f ? 2 * x * x * ((c2 + 1) * 2 * x - c2) : (float)(1 + Math.Pow(2 * x - 2, 3) + c2 * Math.Pow(2 * x - 2, 2)) / 2);
}
}
#endregion
#region Elastic
//24
public class InElasticCurve : Singleton<InElasticCurve>, ICurve
{
public float Evaluate(float x)
{
const float c4 = (2 * (float)Math.PI) / 3;
return (float)((x == 0) ? 0 : ((x == 1) ? 1 : -Math.Pow(2, 10 * x - 10) * Math.Sin((x * 10 - 10.75) * c4)));
}
}
//25
public class OutElasticCurve : Singleton<OutElasticCurve>, ICurve
{
public float Evaluate(float x)
{
const float c4 = (2 * (float)Math.PI) / 3;
return (float)((x == 0) ? 0 : ((x == 1) ? 1 : Math.Pow(2, -10 * x) * Math.Sin((x * 10 - 0.75) * c4) + 1));
}
}
//26
public class InOutElasticCurve : Singleton<InOutElasticCurve>, ICurve
{
public float Evaluate(float x)
{
const float c5 = (2f * (float)Math.PI) / 4.5f;
return (float)((x == 0) ? 0 : ((x == 1) ? 1 : (x < 0.5f ? -(Math.Pow(2, 20 * x - 10) * Math.Sin((20 * x - 11.125f) * c5)) / 2 : (Math.Pow(2, -20 * x + 10) * Math.Sin((20 * x - 11.125f) * c5)) / 2 + 1)));
}
}
#endregion
#region Bounce
//28
public class InBounceCurve : Singleton<InBounceCurve>, ICurve
{
public float Evaluate(float x)
{
return 1 - OutBounceCurve.Instance.Evaluate(1 - x);
}
}
//29
public class OutBounceCurve : Singleton<OutBounceCurve>, ICurve
{
public float Evaluate(float x)
{
const float n1 = 7.5625f;
const float d1 = 2.75f;
if (x < 1 / d1)
{
return n1 * x * x;
}
else if (x < 2 / d1)
{
return n1 * (x -= 1.5f / d1) * x + 0.75f;
}
else if (x < 2.5 / d1)
{
return n1 * (x -= 2.25f / d1) * x + 0.9375f;
}
else
{
return n1 * (x -= 2.625f / d1) * x + 0.984375f;
}
}
}
//30
public class InOutBounceCurve : Singleton<OutBounceCurve>, ICurve
{
public float Evaluate(float x)
{
return x < 0.5f? (1 - Evaluate(1 - 2 * x)) / 2: (1 + Evaluate(2 * x - 1)) / 2;
}
}
#endregion
}