/// <summary>
/// todo: Still have bugs.
/// </summary>
public void FreeCutRect(EasingType 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 = Offset;
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();
}
}
public override void MoveY(EasingType easingEnum, int startTime, int endTime, float startY, float endY)
{
if (_movTime.Max == int.MaxValue || endTime > _movTime.Max)
{
_movTime.Max = endTime;
_y.Target = endY;
}
if (_movTime.Min == int.MinValue || startTime < _movTime.Min)
{
_movTime.Min = startTime;
_y.Source = startY;
}
float ms = Offset;
if (!IsFinished && ms <= _movTime.Min)
{
_y.RealTimeToSource();
}
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
_y.RealTime = startY + (float)easingEnum.Ease(t) * (endY - startY);
}
if (ms >= _movTime.Max)
{
_y.RealTimeToTarget();
}
}
public override void Fade(EasingType 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 = Offset;
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 override void Rotate(EasingType easingEnum, int startTime, int endTime, float startRad, float endRad)
{
//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 = Offset;
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 void Move(EasingType easingEnum, int startTime, int endTime, Gdip.PointF startPoint, Gdip.PointF endPoint)
{
float ms = _timing.Offset;
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 >= MovTime.Max)
{
X.RealTimeToTarget();
Y.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with SCALE or FREERECT at same time!
/// </summary>
public void ScaleVec(EasingType easingEnum, int startTime, int endTime, float startVx, float startVy, float endVx,
float endVy)
{
float ms = _timing.Offset;
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 >= VTime.Max)
{
Vx.RealTimeToTarget();
Vy.RealTimeToTarget();
}
}
public void Color(EasingType easingEnum, int startTime, int endTime, float r1, float g1, float b1, float r2, float g2, float b2)
{
float ms = _timing.Offset;
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
R.RealTime = r1 + (float)easingEnum.Ease(t) * (r2 - r1);
G.RealTime = g1 + (float)easingEnum.Ease(t) * (g2 - g1);
B.RealTime = b1 + (float)easingEnum.Ease(t) * (b2 - b1);
}
if (ms >= CTime.Max)
{
R.RealTimeToTarget();
G.RealTimeToTarget();
B.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with SCALE or FREERECT at same time!
/// </summary>
public override void ScaleVec(EasingType easingEnum, int startTime, int endTime, float startVx, float startVy, float endVx,
float endVy)
{
if (_vTime.Max == int.MaxValue || endTime > _vTime.Max)
{
_vTime.Max = endTime;
_vx.Target = endVx;
_vy.Target = endVy;
}
if (_vTime.Min == int.MinValue || startTime < _vTime.Min)
{
_vTime.Min = startTime;
_vx.Source = startVx;
_vy.Source = startVy;
}
float ms = Offset;
if (!IsFinished && ms <= _vTime.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 >= _vTime.Max)
{
_vx.RealTimeToTarget();
_vy.RealTimeToTarget();
}
}
/// <summary>
/// Do not use with MOVEX or MOVEY at same time!
/// </summary>
public override void Move(EasingType easingEnum, int startTime, int endTime, Gdip.PointF startPoint, Gdip.PointF endPoint)
{
if (_movTime.Max == int.MaxValue || endTime >= _movTime.Max)
{
_movTime.Max = endTime;
_x.Target = endPoint.X;
_y.Target = endPoint.Y;
}
if (_movTime.Min == int.MinValue || startTime <= _movTime.Min)
{
_movTime.Min = startTime;
_x.Source = startPoint.X;
_y.Source = startPoint.Y;
}
float ms = Offset;
if (!IsFinished && ms <= _movTime.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 >= _movTime.Max)
{
_x.RealTimeToTarget();
_y.RealTimeToTarget();
}
}
public void Fade(EasingType easingEnum, int startTime, int endTime, float startOpacity, float endOpacity)
{
float ms = _timing.Offset;
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 void Rotate(EasingType easingEnum, int startTime, int endTime, float startRad, float endRad)
{
float ms = _timing.Offset;
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
Rad.RealTime = startRad + (float)easingEnum.Ease(t) * (endRad - startRad);
}
if (ms >= RotateTime.Max)
{
Rad.RealTimeToTarget();
}
}
public void MoveY(EasingType easingEnum, int startTime, int endTime, float startY, float endY)
{
float ms = _timing.Offset;
if (!IsFinished && ms >= startTime && ms <= endTime)
{
var t = (ms - startTime) / (endTime - startTime);
Y.RealTime = startY + (float)easingEnum.Ease(t) * (endY - startY);
}
if (ms >= MovTime.Max)
{
Y.RealTimeToTarget();
}
}
