public override void Rotate(EasingEnum easingEnum, int startTime, int endTime, float startDeg, float endDeg)
{
float startRad = (float)(Math.PI * startDeg / 180d);
float endRad = (float)(Math.PI * endDeg / 180d);
if (_rotateTime.Max == int.MaxValue || endTime > _rotateTime.Max)
{
_rotateTime.Max = endTime;
_r.Target = endRad;
}
if (_rotateTime.Min == int.MinValue || startTime < _rotateTime.Min)
{
_rotateTime.Min = startTime;
_r.Source = startRad;
}
float ms = _watch.ElapsedMilliseconds;
if (!IsFinished && ms <= _rotateTime.Min)
{
_r.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_r.RealTime = startRad + (float)easingEnum.Ease(t) * (endRad - startRad);
}
if (ms >= _rotateTime.Max)
{
_r.RealTimeToTarget();
}
}
public override void Fade(EasingEnum easingEnum, int startTime, int endTime, float startOpacity, float endOpacity)
{
if (_fadeTime.Max == int.MaxValue || endTime > _fadeTime.Max)
{
_fadeTime.Max = endTime;
_f.Target = endOpacity;
}
if (_fadeTime.Min == int.MinValue || startTime < _fadeTime.Min)
{
_fadeTime.Min = startTime;
_f.Source = startOpacity;
}
float ms = _watch.ElapsedMilliseconds;
if (!IsFinished && ms <= _fadeTime.Min)
{
_f.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_f.RealTime = startOpacity + (float)easingEnum.Ease(t) * (endOpacity - startOpacity);
}
if (ms >= _fadeTime.Max)
{
_f.RealTimeToTarget();
}
}
public QuaternionTween(
float duration, Quaternion tweenFrom, Quaternion tweenTo, EasingEnum easingType, Action <Quaternion> onUpdated, Action <CUnit> onCompleted
)
: base(duration, tweenFrom, Quaternion.identity, easingType, onUpdated, onCompleted)
{
this.tweenTo = tweenTo;
}
public static NormalizedEasing NormalizedFunc(this EasingEnum self)
{
switch (self)
{
case EasingEnum.Linear:
return(LinearNormalized);
case EasingEnum.QuadEaseIn:
return(QuadEaseInNormalized);
case EasingEnum.QuadEaseOut:
return(QuadEaseOutNormalized);
case EasingEnum.QuadEaseInOut:
return(QuadEaseInOutNormalized);
case EasingEnum.QuadEaseOutIn:
return(QuadEaseOutInNormalized);
case EasingEnum.BackEaseIn:
return(BackEaseInNormalized);
case EasingEnum.BackEaseOut:
return(BackEaseOutNormalized);
case EasingEnum.BackEaseInOut:
return(BackEaseInOutNormalized);
case EasingEnum.BackEaseOutIn:
return(BackEaseOutInNormalized);
case EasingEnum.ElasticEaseIn:
return(ElasticEaseInNormalized);
case EasingEnum.ElasticEaseOut:
return(ElasticEaseOutNormalized);
case EasingEnum.ElasticEaseInOut:
return(ElasticEaseInOutNormalized);
case EasingEnum.ElasticEaseOutIn:
return(ElasticEaseOutInNormalized);
case EasingEnum.BounceEaseIn:
return(BounceEaseInNormalized);
case EasingEnum.BounceEaseOut:
return(BounceEaseOutNormalized);
default:
throw new UnityException("unknown type " + self);
}
}
/// <summary>
/// todo: Still have bugs.
/// </summary>
public void FreeCutRect(EasingEnum easingEnum, int startTime, int endTime, Mathe.RawRectangleF startRect,
Mathe.RawRectangleF endRect)
{
if (_inRectTime.Max == int.MaxValue || endTime > _inRectTime.Max)
{
_inRectTime.Max = endTime;
_inX.Target = endRect.Left;
_inY.Target = endRect.Top;
_inW.Target = endRect.Right - endRect.Left;
_inH.Target = endRect.Bottom - endRect.Top;
}
if (_inRectTime.Min == int.MinValue || startTime < _inRectTime.Min)
{
_inRectTime.Min = startTime;
_inX.Source = startRect.Left;
_inY.Source = startRect.Top;
_inW.Source = startRect.Right - startRect.Left;
_inH.Source = startRect.Bottom - startRect.Top;
}
float ms = _watch.ElapsedMilliseconds;
if (!IsFinished && ms <= _inRectTime.Min)
{
_inX.RealTimeToSource();
_inY.RealTimeToSource();
_inW.RealTimeToSource();
_inH.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_inX.RealTime = startRect.Left + (float)easingEnum.Ease(t) * (endRect.Left - startRect.Left);
_inY.RealTime = startRect.Top + (float)easingEnum.Ease(t) * (endRect.Top - startRect.Top);
float r = startRect.Right + (float)easingEnum.Ease(t) * (endRect.Right - startRect.Right);
float b = startRect.Bottom + (float)easingEnum.Ease(t) * (endRect.Bottom - startRect.Bottom);
_inW.RealTime = r - _inX.RealTime;
_inH.RealTime = b - _inY.RealTime;
}
if (ms >= _inRectTime.Max)
{
_inX.RealTimeToTarget();
_inY.RealTimeToTarget();
_inW.RealTimeToTarget();
_inH.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with any MOVE or any SCALE at same time!
/// </summary>
public void FreeRect(EasingEnum easingEnum, int startTime, int endTime, Mathe.RawRectangleF startRect,
Mathe.RawRectangleF endRect)
{
if (_rectTime.Max == int.MaxValue || endTime > _rectTime.Max)
{
_rectTime.Max = endTime;
_x.Target = endRect.Left;
_y.Target = endRect.Top;
_w.Target = endRect.Right - endRect.Left;
_h.Target = endRect.Bottom - endRect.Top;
}
if (_rectTime.Min == int.MinValue || startTime < _rectTime.Min)
{
_rectTime.Min = startTime;
_x.Source = startRect.Left;
_y.Source = startRect.Top;
_w.Source = startRect.Right - startRect.Left;
_h.Source = startRect.Bottom - startRect.Top;
}
float ms = _offset;
if (!IsFinished && ms <= _rectTime.Min)
{
_x.RealTimeToSource();
_y.RealTimeToSource();
_w.RealTimeToSource();
_h.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_x.RealTime = startRect.Left + (float)easingEnum.Ease(t) * (endRect.Left - startRect.Left);
_y.RealTime = startRect.Top + (float)easingEnum.Ease(t) * (endRect.Top - startRect.Top);
float r = startRect.Right + (float)easingEnum.Ease(t) * (endRect.Right - startRect.Right);
float b = startRect.Bottom + (float)easingEnum.Ease(t) * (endRect.Bottom - startRect.Bottom);
_w.RealTime = r - _x.RealTime;
_h.RealTime = b - _y.RealTime;
}
if (ms >= _rectTime.Max)
{
_x.RealTimeToTarget();
_y.RealTimeToTarget();
_w.RealTimeToTarget();
_h.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with SCALE or FREERECT at same time!
/// </summary>
public override void ScaleVec(EasingEnum easingEnum, int startTime, int endTime, float startVx, float startVy, float endVx,
float endVy)
{
if (_rectTime.Max == int.MaxValue || endTime > _rectTime.Max)
{
_rectTime.Max = endTime;
_vx.Target = endVx;
_vy.Target = endVy;
}
if (_rectTime.Min == int.MinValue || startTime < _rectTime.Min)
{
_rectTime.Min = startTime;
_vx.Source = startVx;
_vy.Source = startVy;
}
float ms = _watch.ElapsedMilliseconds;
if (!IsFinished && ms <= _rectTime.Min)
{
_vx.RealTimeToSource();
_vy.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_vx.RealTime = startVx + (float)easingEnum.Ease(t) * (endVx - startVx);
_vy.RealTime = startVy + (float)easingEnum.Ease(t) * (endVy - startVy);
}
if (ms >= _rectTime.Max)
{
_vx.RealTimeToTarget();
_vy.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with MOVEX or MOVEY at same time!
/// </summary>
public override void Move(EasingEnum easingEnum, int startTime, int endTime, Gdip.PointF startPoint, Gdip.PointF endPoint)
{
if (_rectTime.Max == int.MaxValue || endTime > _rectTime.Max)
{
_rectTime.Max = endTime;
_x.Target = endPoint.X;
_y.Target = endPoint.Y;
}
if (_rectTime.Min == int.MinValue || startTime < _rectTime.Min)
{
_rectTime.Min = startTime;
_x.Source = startPoint.X;
_y.Source = startPoint.Y;
}
float ms = _watch.ElapsedMilliseconds;
if (!IsFinished && ms <= _rectTime.Min)
{
_x.RealTimeToSource();
_y.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_x.RealTime = startPoint.X + (float)easingEnum.Ease(t) * (endPoint.X - startPoint.X);
_y.RealTime = startPoint.Y + (float)easingEnum.Ease(t) * (endPoint.Y - startPoint.Y);
}
if (ms >= _rectTime.Max)
{
_x.RealTimeToTarget();
_y.RealTimeToTarget();
}
}
public static double Ease(this EasingEnum easingEnum, double value) => easingEnum.ToEasingFunction().Invoke(value);
public Vector3Tween(float duration, Vector3 tweenFrom, Vector3 tweenTo, EasingEnum easingType, Action <Vector3> onUpdated, Action <CUnit> onCompleted = null)
: base(duration, tweenFrom, tweenTo - tweenFrom, easingType, onUpdated, onCompleted)
{
}
public FloatTween(float duration, float tweenFrom, float tweenTo, EasingEnum easingType, Action <float> onUpdated, Action <CUnit> onCompleted = null)
: base(duration, tweenFrom, tweenTo - tweenFrom, easingType, onUpdated, onCompleted)
{
}
public EasingEnum GetEasing(EasingEnum e)
{
return(easingOverride ? easing : e);
}
Easings GetEasingClass(EasingEnum e)
{
return((Easings)System.Activator.CreateInstance(System.Reflection.Assembly.GetAssembly(typeof(Easings)).GetType("Uween." + e.ToString())));
}
public static Func <double, double> ToEasingFunction(this EasingEnum easingEnum)
{
switch (easingEnum)
{
default:
case EasingEnum.Linear: return(Linear);
case EasingEnum.EasingIn:
case EasingEnum.QuadIn: return(QuadIn);
case EasingEnum.EasingOut:
case EasingEnum.QuadOut: return(QuadOut);
case EasingEnum.QuadInOut: return(QuadInOut);
case EasingEnum.CubicIn: return(CubicIn);
case EasingEnum.CubicOut: return(CubicOut);
case EasingEnum.CubicInOut: return(CubicInOut);
case EasingEnum.QuartIn: return(QuartIn);
case EasingEnum.QuartOut: return(QuartOut);
case EasingEnum.QuartInOut: return(QuartInOut);
case EasingEnum.QuintIn: return(QuintIn);
case EasingEnum.QuintOut: return(QuintOut);
case EasingEnum.QuintInOut: return(QuintInOut);
case EasingEnum.SineIn: return(SineIn);
case EasingEnum.SineOut: return(SineOut);
case EasingEnum.SineInOut: return(SineInOut);
case EasingEnum.ExpoIn: return(ExpoIn);
case EasingEnum.ExpoOut: return(ExpoOut);
case EasingEnum.ExpoInOut: return(ExpoInOut);
case EasingEnum.CircIn: return(CircIn);
case EasingEnum.CircOut: return(CircOut);
case EasingEnum.CircInOut: return(CircInOut);
case EasingEnum.ElasticIn: return(ElasticIn);
case EasingEnum.ElasticOut: return(ElasticOut);
case EasingEnum.ElasticHalfOut: return(ElasticOutHalf);
case EasingEnum.ElasticQuarterOut: return(ElasticOutQuarter);
case EasingEnum.ElasticInOut: return(ElasticInOut);
case EasingEnum.BackIn: return(BackIn);
case EasingEnum.BackOut: return(BackOut);
case EasingEnum.BackInOut: return(BackInOut);
case EasingEnum.BounceIn: return(BounceIn);
case EasingEnum.BounceOut: return(BounceOut);
case EasingEnum.BounceInOut: return(BounceInOut);
}
}
public abstract void ScaleVec(EasingEnum easingEnum, int startTime, int endTime, float startWidth,
float startHeight, float endWidth, float endHeight);
public abstract void Rotate(EasingEnum easingEnum, int startTime, int endTime, float startDeg, float endDeg);
public abstract void Move(EasingEnum easingEnum, int startTime, int endTime, Gdip.PointF startPoint,
Gdip.PointF endPoint);
public abstract void Fade(EasingEnum easingEnum, int startTime, int endTime, float startOpacity,
float endOpacity);
