public float InOut(float time)
{
switch (type)
{
case AnimationEasingType.LinearEasing: return(time);
case AnimationEasingType.QuadraticEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.CubicEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.QuarticEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.QuinticEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.SinusoidalEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.ExponentialEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.CircularEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.BounceEasing: return(EasingHelper.InOut(this, time));
case AnimationEasingType.BackEasing: return(EasingHelper.BackInOut(time));
case AnimationEasingType.ElasticEasing: return(EasingHelper.InOut(this, time));
}
return(time);
}
public float In(float time)
{
switch (type)
{
case AnimationEasingType.LinearEasing: return(time);
case AnimationEasingType.QuadraticEasing: return(time * time);
case AnimationEasingType.CubicEasing: return(time * time * time);
case AnimationEasingType.QuarticEasing: return(Mathf.Pow(time, 4));
case AnimationEasingType.QuinticEasing: return(Mathf.Pow(time, 5));
case AnimationEasingType.SinusoidalEasing: return(Mathf.Sin((time - 1) * (Mathf.PI / 2)) + 1);
case AnimationEasingType.ExponentialEasing: return(Mathf.Pow(2, 10 * (time - 1)));
case AnimationEasingType.CircularEasing: return(-1 * Mathf.Sqrt(1 - time * time) + 1);
case AnimationEasingType.BounceEasing: return(1 - Out(1 - time));
case AnimationEasingType.BackEasing: return(EasingHelper.BackIn(time));
case AnimationEasingType.ElasticEasing: return(ElasticIn(time));
}
return(time);
}
public float In(float time) {
switch (type) {
case AnimationEasingType.Linear:
return time;
case AnimationEasingType.Quad:
return (time * time);
case AnimationEasingType.Cube:
return (time * time * time);
case AnimationEasingType.Quart:
return Mathf.Pow(time, 4f);
case AnimationEasingType.Quint:
return Mathf.Pow(time, 5f);
case AnimationEasingType.Sine:
return Mathf.Sin((time - 1f) * (Mathf.PI / 2f)) + 1f;
case AnimationEasingType.Expo:
return Mathf.Pow(2f, 10f * (time - 1f));
case AnimationEasingType.Circ:
return (-1f * Mathf.Sqrt(1f - time * time) + 1f);
case AnimationEasingType.Back:
return time * time * ((s + 1f) * time - s);
case AnimationEasingType.Bounce:
return 1f - Out(1f - time);
case AnimationEasingType.Elastic:
return EasingHelper.Elastic(time, EasingType.In);
case AnimationEasingType.Spring:
return EasingHelper.Spring(time);
}
return time;
}
public float InOut(float time) {
switch (type) {
case AnimationEasingType.Linear:
return time;
case AnimationEasingType.Quad:
case AnimationEasingType.Cube:
case AnimationEasingType.Quart:
case AnimationEasingType.Quint:
case AnimationEasingType.Sine:
case AnimationEasingType.Expo:
case AnimationEasingType.Circ:
case AnimationEasingType.Bounce:
case AnimationEasingType.Elastic:
return EasingHelper.ElasticInOut(this, time);
case AnimationEasingType.Back: {
time *= 2f;
if (time < 1f) {
return 0.5f * (time * time * ((s2 + 1f) * time - s2));
} else {
time -= 2f;
return 0.5f * (time * time * ((s2 + 1f) * time + s2) + 2f);
}
}
case AnimationEasingType.Spring:
return EasingHelper.Spring(time);
}
return time;
}
private IEnumerator MoveShakeStrength(ShakeData shakeData, Action onShakeCompleted = null)
{
float durationOffset = UnityEngine.Random.Range(-shakeData.randomDurationOffset, shakeData.randomDurationOffset);
float targetStrengthOffset = UnityEngine.Random.Range(-shakeData.randomTargetStrengthOffset, shakeData.randomTargetStrengthOffset);
float duration = shakeData.duration + durationOffset;
float targetStrength = shakeData.targetStrength + targetStrengthOffset;
float startStrength = shakeStrength;
float time = 0;
while (time < duration)
{
float absoluteValue = time / duration;
float easedAbsoluteValue = EasingHelper.EaseInSine(absoluteValue);
float strengthProgess = targetStrength - startStrength;
float easedStrengthProgess = strengthProgess * easedAbsoluteValue;
shakeStrength = startStrength + easedStrengthProgess;
time += Time.deltaTime;
yield return(new WaitForEndOfFrame());
}
shakeStrength = targetStrength;
if (onShakeCompleted != null)
{
onShakeCompleted();
}
}
private IEnumerator EasedLerpPosition(Vector2 start, Vector2 destination, EasingType easingType = EasingType.EaseLinear, Action onFinishMoveAlongPath = null)
{
float time = 0.0f;
float fromToOnPathDistance = Vector3.Distance(start, destination);
float duration = fromToOnPathDistance / speed;
while (time < duration)
{
float progress = time / duration;
float easedProgress = EasingHelper.Ease(easingType, progress);
time += Time.deltaTime;
transform.position = Vector2.Lerp(start, destination, easedProgress);
yield return(new WaitForEndOfFrame());
}
yield return(new WaitForEndOfFrame());
if (onFinishMoveAlongPath != null)
{
onFinishMoveAlongPath();
}
}
public float Out(float time)
{
switch (type)
{
case AnimationEasingType.LinearEasing: return(time);
case AnimationEasingType.QuadraticEasing: return(time * (time - 2) * -1);
case AnimationEasingType.CubicEasing: return(Mathf.Pow(time - 1, 3) + 1);
case AnimationEasingType.QuarticEasing: return((Mathf.Pow(time - 1, 4) - 1) * -1);
case AnimationEasingType.QuinticEasing: return(Mathf.Pow(time - 1, 5) + 1);
case AnimationEasingType.SinusoidalEasing: return(Mathf.Sin(time * (Mathf.PI / 2)));
case AnimationEasingType.ExponentialEasing: return(-1 * Mathf.Pow(2, -10 * time) + 1);
case AnimationEasingType.CircularEasing: return(Mathf.Sqrt(1 - Mathf.Pow(time - 1, 2)));
case AnimationEasingType.BounceEasing: return(EasingHelper.BounceOut(time));
case AnimationEasingType.BackEasing: return(EasingHelper.BackOut(time));
case AnimationEasingType.ElasticEasing: return(ElasticOut(time));
}
return(time);
}
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(EasingHelper.Lerp(linearStep, easedStep, Math.Abs(acceleration)));
}
protected override Task BeginAnimation()
{
if (Target == null)
{
throw new NullReferenceException("Null Target property.");
}
return(Target.FadeTo(Opacity, Convert.ToUInt32(Duration), EasingHelper.GetEasing(Easing)));
}
protected override void Draw(CanvasDrawingSession drawingSession
#if WINDOWS_UWP
, CanvasSpriteBatch spriteBatch
#endif
)
{
// 逆向遍历队列，可以让新粒子绘制在旧粒子下方，这样当很多粒子在同一个位置生成时，效果较好
for (int i = ActiveParticles.Count - 1; i >= 0; i--)
{
Particle particle = ActiveParticles[i];
// NormalizedLifeTime 是一个0到1之间的值，用来表示粒子在生命周期中的进度，这个值接近0或接近1时，
// 粒子将会渐隐/渐显，使用它来计算粒子的透明度和缩放
float normalizedLifetime = particle.TimeSinceStart / 4;
if (normalizedLifetime > 1)
{
normalizedLifetime = 1;
}
// We want particles to fade in and fade out, so we'll calculate alpha to be
// (normalizedLifetime) * (1 - normalizedLifetime). This way, when normalizedLifetime
// is 0 or 1, alpha is 0. The maximum value is at normalizedLifetime = .5, and is:
//
// (normalizedLifetime) * (1-normalizedLifetime)
// (.5) * (1-.5)
// .25
//
// Since we want the maximum alpha to be 1, not .25, we'll scale the entire equation by 4.
float alpha = (float)EasingHelper.QuinticEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseOut, normalizedLifetime);
var x = particle.ScaleX;
var y = particle.ScaleY;
// Make particles grow as they age.
// They'll start at 75% of their size, and increase to 100% once they're finished.
if (isImmersive)
{
alpha *= 0.8f;
x *= 1.2f;
y *= 1.2f;
}
#if WINDOWS_UWP
if (spriteBatch != null)
{
spriteBatch.Draw(smokeSurfaces[particle.Key], particle.Position, new Vector4(1, 1, 1, alpha), bitmapCenter,
particle.Rotation, new Vector2(x, y), CanvasSpriteFlip.None);
}
else
#endif
{
// Compute a transform matrix for this particle.
var transform = Matrix3x2.CreateRotation(particle.Rotation, bitmapCenter) *
Matrix3x2.CreateScale(x, y, bitmapCenter) *
Matrix3x2.CreateTranslation(particle.Position - bitmapCenter);
// Draw the particle.
drawingSession.DrawImage(smokeSurfaces[particle.Key], 0, 0, bitmapBounds, alpha, CanvasImageInterpolation.Linear, new Matrix4x4(transform));
}
}
}
protected override Task ResetAnimation()
{
if (Target == null)
{
throw new NullReferenceException("Null Target property.");
}
return(Target.RelScaleTo(Scale, Convert.ToUInt32(Duration), EasingHelper.GetEasing(Easing)));
}
public void Update()
{
if (surfaceLoaded)
{
if (nowFrame < inFrames)
{
var progress = nowFrame / (float)inFrames;
progress = (float)EasingHelper.QuinticEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseOut, progress);
position.X = (float)(xOffset * (progress - 0.5)) / 2;
position.Y = (float)(yOffset * (progress - 0.5)) / 2;
opcity = 0.8f * progress;
}
nowFrame++;
rotation = 0.000174532922222222f * nowFrame;
}
}
protected override async void Invoke(VisualElement sender)
{
if (TargetProperty == null)
{
throw new NullReferenceException("Null Target property.");
}
if (Delay > 0)
await Task.Delay(Delay);
SetDefaultFrom((double)sender.GetValue(TargetProperty));
sender.Animate($"AnimateInt{TargetProperty.PropertyName}", new Animation((progress) =>
{
sender.SetValue(TargetProperty, AnimationHelper.GetIntValue((int)From, (int)To, progress));
}),
length: Duration,
easing: EasingHelper.GetEasing(Easing));
}
public float Out(float time) {
switch (type) {
case AnimationEasingType.Linear:
return time;
case AnimationEasingType.Quad:
return (time * (time - 2f) * -1f);
case AnimationEasingType.Cube:
return (Mathf.Pow(time - 1f, 3f) + 1f);
case AnimationEasingType.Quart:
return (Mathf.Pow(time - 1f, 4f) - 1f) * -1f;
case AnimationEasingType.Quint:
return (Mathf.Pow(time - 1f, 5f) + 1f);
case AnimationEasingType.Sine:
return Mathf.Sin(time * (Mathf.PI / 2f));
case AnimationEasingType.Expo:
return (-1f * Mathf.Pow(2f, -10f * time) + 1f);
case AnimationEasingType.Circ:
return Mathf.Sqrt(1f - Mathf.Pow(time - 1f, 2f));
case AnimationEasingType.Back:
time = time - 1f;
return (time * time * ((s + 1f) * time + s) + 1f);
case AnimationEasingType.Bounce: {
if (time < (1f / 2.75f)) {
return (7.5625f * time * time);
} else if (time < (2f / 2.75f)) {
time -= (1.5f / 2.75f);
return (7.5625f * time * time + 0.75f);
} else if (time < (2.5f / 2.75f)) {
time -= (2.25f / 2.75f);
return (7.5625f * time * time + 0.9375f);
} else {
time -= (2.625f / 2.75f);
return (7.5625f * time * time + 0.984375f);
}
}
case AnimationEasingType.Elastic:
return EasingHelper.Elastic(time, EasingType.Out);
case AnimationEasingType.Spring:
return EasingHelper.Spring(time);
}
return time;
}
public void update(Vector2 size)
{
if (tempSurface != null && canDraw)
{
scale.X = (float)(size.X / bound.Width > size.Y / bound.Height ? size.X / bound.Width : size.Y / bound.Height);
scale.Y = scale.X;
position = size / 2;
if (isImmersive)
{
nowFrame++;
if (nowFrame <= inFrames)
{
opacity = (float)EasingHelper.QuinticEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseOut, (double)nowFrame / inFrames);
}
}
else if (nowFrame != 0)
{
nowFrame -= 1;
opacity = (float)EasingHelper.QuinticEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseOut, (double)nowFrame / inFrames);
if (nowFrame == 0)
{
canDraw = false;
}
}
if (enableBlur)
{
blurFrame++;
if (blurFrame <= inFrames)
{
blur.BlurAmount = blurAmount * (float)EasingHelper.CircleEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseOut, (double)blurFrame / inFrames);
}
}
else if (blurFrame != 0)
{
blurFrame--;
blur.BlurAmount = blurAmount * (float)EasingHelper.CircleEase(Windows.UI.Xaml.Media.Animation.EasingMode.EaseIn, (double)blurFrame / inFrames);
}
}
}
public EasingFunc(float duration, EEasingMethod method = EEasingMethod.Sine, EEasingType type = EEasingType.In)
{
m_Method = EasingHelper.Get(method, type);
Duration = duration;
}
override protected void CreateChildren()
{
base.CreateChildren();
#region List 1
List list1 = new List
{
PercentWidth = 100,
PercentHeight = 100,
MinWidth = 200,
MinHeight = 100,
Height = 200,
DataProvider = new ArrayList(EasingHelper.GetEasingList()),
SelectedItem = "Bounce"
};
AddContentChild(list1);
#endregion
#region List 2
List list2 = new List
{
PercentWidth = 100,
PercentHeight = 100,
MinHeight = 100,
Height = 200,
DataProvider = new ArrayList(
Application.isWebPlayer
? ResolutionHelper.GetResolutionList()
: ResolutionHelper.GetDummyResolutionList())
};
AddContentChild(list2);
#endregion
#region Drow down list
DropDownList dropDownList = new DropDownList
{
PercentWidth = 100,
MinWidth = 200,
DataProvider = new ArrayList(
Application.isWebPlayer
? ResolutionHelper.GetResolutionList()
: ResolutionHelper.GetDummyResolutionList())
};
AddContentChild(dropDownList);
dropDownList = new DropDownList
{
PercentWidth = 100,
MinWidth = 200,
DataProvider = new ArrayList(new System.Collections.Generic.List <object>
{
new ListItem(1, "Zagreb"),
new ListItem(2, "Osijek"),
new ListItem(3, "Rijeka"),
new ListItem(4, "Split"),
new ListItem(5, "Ljubljana"),
new ListItem(6, "Wiena"),
new ListItem(7, "Munich"),
new ListItem(8, "Berlin")
})
};
AddContentChild(dropDownList);
List list3 = new List
{
PercentWidth = 100,
MinHeight = 100,
Height = 200,
DataProvider = new ArrayList(EasingHelper.GetEasingInOutList()),
SelectedItem = "EaseIn"
};
AddContentChild(list3);
#endregion
#region Button
Button btn = new Button
{
Text = "Show alert",
SkinClass = typeof(ImageButtonSkin),
Icon = Resources.Load <Texture>("Icons/tab-comment")
//StyleDeclaration = new StyleDeclaration(RectButtonSkin.Instance, "button"),
};
btn.Click += delegate
{
Alert.Show("Hi!", "This is the alert", AlertButtonFlag.Ok);
};
ControlBarGroup.AddChild(btn);
#endregion
}
public void LerpTest()
{
Assert.Equal(0.5, EasingHelper.Lerp(0, 1, 0.5));
Assert.Equal(0.25, EasingHelper.Lerp(0, 1, 0.25));
Assert.Equal(0.75, EasingHelper.Lerp(0, 1, 0.75));
}
public void QubicTest()
{
Assert.Equal(1, EasingHelper.Cubic(1));
Assert.Equal(0.5, EasingHelper.Cubic(0.5));
Assert.Equal(0, EasingHelper.Cubic(0));
}
public void EaseInTest()
{
Assert.Equal(1, EasingHelper.EaseIn(1));
Assert.Equal(0, EasingHelper.EaseIn(0));
}
public void EaseOutTest()
{
Assert.Equal(1, EasingHelper.EaseOut(1));
Assert.Equal(0, EasingHelper.EaseOut(0));
}
private double GetElasticFactor(double percent)
{
return(ElasticFactor * (1 - EasingHelper.QuinticEase(EasingMode.EaseOut, percent)));
}
