private void AssertStatus(TweenStatus status)
{
if (this.status != status)
{
throw new InvalidOperationException($"Status error. need {status}, current is {this.status}");
}
}
private void AssertNotStatus(TweenStatus status)
{
if (this.status == status)
{
throw new InvalidOperationException($"Status error. can not be {status}");
}
}
public void Resume()
{
switch (this.Status)
{
case TweenStatus.Pausing:
this.Status = TweenStatus.Running;
break;
}
}
public void Pause()
{
switch (this.Status)
{
case TweenStatus.Running:
case TweenStatus.WaitingToStop:
this.Status = TweenStatus.Pausing;
break;
}
}
public void Stop()
{
switch (this.Status)
{
case TweenStatus.Stopped:
break;
default:
this.Status = TweenStatus.WaitingToStop;
break;
}
}
private void StartCore()
{
this.Reset();
switch (this.Status)
{
case TweenStatus.Stopped:
this.Status = TweenStatus.Running;
TweenEngine.Instance.Add((ITween)this);
break;
default:
this.Status = TweenStatus.Running;
break;
}
}
public void Resume()
{
switch (this.Status)
{
case TweenStatus.Pausing:
Status = TweenStatus.Running;
break;
case TweenStatus.Stopped:
case TweenStatus.Running:
case TweenStatus.WaitingToStop:
default:
break;
}
}
void StartCore()
{
Reset();
switch (this.Status)
{
case TweenStatus.Stopped:
this.Status = TweenStatus.Running;
TweenEngine.Instance.Add(this);
break;
case TweenStatus.Running:
case TweenStatus.Pausing:
case TweenStatus.WaitingToStop:
default:
Status = TweenStatus.Running;
break;
}
}
private void DoTweenInternal(SingleTween[] tweens, UnityEvent beforeEvent, UnityEvent afterEvent, Action action)
{
float lastTweenInsertTime = 0;
bool needCallImmediately = false;
mSequence?.Kill();
mSequence = null;
beforeEvent?.Invoke();
if (tweens.Length > 0)
{
mSequence = DOTween.Sequence().SetUpdate(UpdateType, IgnoreTimeScale);
foreach (var tween in tweens)
{
switch (tween.AddItemType)
{
case SingleTween.ItemType.Tweener:
if (!tween.IsValid)
{
continue;
}
switch (tween.ItemLinkType)
{
case SingleTween.LinkType.Append:
lastTweenInsertTime = mSequence.Duration(false);
needCallImmediately = lastTweenInsertTime < 1e-4;
if (tween.OverrideStartStatus)
{
if (needCallImmediately)
{
tween.SetStartStatus();
}
else
{
mSequence.AppendCallback(tween.SetStartStatus);
}
}
mSequence.Append(tween.BuildTween());
break;
case SingleTween.LinkType.Join:
if (tween.OverrideStartStatus)
{
if (needCallImmediately)
{
tween.SetStartStatus();
}
else
{
mSequence.InsertCallback(lastTweenInsertTime, tween.SetStartStatus);
}
}
mSequence.Join(tween.BuildTween());
break;
case SingleTween.LinkType.Insert:
lastTweenInsertTime = tween.AtPosition;
needCallImmediately = lastTweenInsertTime < 1e-4;
if (tween.OverrideStartStatus)
{
if (needCallImmediately)
{
tween.SetStartStatus();
}
else
{
mSequence.InsertCallback(lastTweenInsertTime, tween.SetStartStatus);
}
}
mSequence.Insert(lastTweenInsertTime, tween.BuildTween());
break;
default:
Debug.LogError("LinkType does not contain an enumeration of this type: " + (int)tween.ItemLinkType);
break;
}
break;
case SingleTween.ItemType.Delay:
if (tween.Duration > 0)
{
mSequence.AppendInterval(tween.Duration);
}
break;
case SingleTween.ItemType.Callback:
//Callback also will change lastTweenInsertTime
switch (tween.ItemLinkType)
{
case SingleTween.LinkType.Append:
lastTweenInsertTime = mSequence.Duration(false);
mSequence.AppendCallback(tween.InvokeCallback);
break;
case SingleTween.LinkType.Join:
mSequence.InsertCallback(lastTweenInsertTime, tween.InvokeCallback);
break;
case SingleTween.LinkType.Insert:
lastTweenInsertTime = tween.AtPosition;
mSequence.InsertCallback(tween.AtPosition, tween.InvokeCallback);
break;
default:
Debug.LogError("LinkType does not contain an enumeration of this type: " + (int)tween.ItemLinkType);
break;
}
break;
default:
Debug.LogError("ItemType does not contain an enumeration of this type: " + (int)tween.AddItemType);
break;
}
}
mSequence.OnComplete(() =>
{
mSequence = null;
Status = TweenStatus.None;
afterEvent?.Invoke();
action?.Invoke();
});
}
else
{
Status = TweenStatus.None;
afterEvent?.Invoke();
action?.Invoke();
}
}
public void DoCloseTween(Action action)
{
Status = TweenStatus.Close;
DoTweenInternal(CloseSingleTweens, OnCloseBeforeAnim, OnCloseAfterAnim, action);
}
public void DoStartTween(Action action)
{
RecoverStatus();
Status = TweenStatus.Start;
DoTweenInternal(StartSingleTweens, OnStartBeforeAnim, OnStartAfterAnim, action);
}
public bool MoveNext(ref float deltaTime, ref float unscaledDeltaTime)
{
switch (this.Status)
{
case TweenStatus.Running:
if ((double)this.delayTime != 0.0)
{
this.delayTime -= !this.Settings.IsIgnoreTimeScale ? deltaTime : unscaledDeltaTime;
if ((double)this.delayTime > 0.0)
{
return(true);
}
this.delayTime = 0.0f;
}
float time = !this.Settings.IsIgnoreTimeScale ? (this.currentTime += deltaTime) : (this.currentTime += unscaledDeltaTime);
bool flag = false;
if ((double)time >= (double)this.duration)
{
time = this.duration;
flag = true;
}
float ratio = this.easingFunction(time, this.duration);
TProperty newValue;
this.CreateValue(ref this.from, ref this.difference, ref ratio, out newValue);
this.setter(this.target, ref newValue);
if (flag)
{
++this.repeatCount;
switch (this.Settings.LoopType)
{
case LoopType.Restart:
this.from = this.originalFrom;
this.currentTime = 0.0f;
break;
case LoopType.Cycle:
TProperty from = this.from;
this.from = this.to;
this.to = from;
this.difference = this.GetDifference(this.from, this.to);
this.currentTime = 0.0f;
break;
case LoopType.CycleOnce:
if (this.repeatCount == 2)
{
return(false);
}
goto case LoopType.Cycle;
default:
if (this.completedEvent != null)
{
this.completedEvent.OnNext(Unit.get_Default());
}
return(false);
}
}
return(true);
case TweenStatus.Pausing:
return(true);
default:
this.Status = TweenStatus.Stopped;
return(false);
}
}
/// <summary>
/// Called frame TweenManager.
/// </summary>
public bool MoveNext(ref float deltaTime, ref float unscaledDeltaTime)
{
switch (this.Status)
{
case TweenStatus.Pausing:
return(true);
case TweenStatus.Running:
break;
case TweenStatus.WaitingToStop:
case TweenStatus.Stopped:
default:
this.Status = TweenStatus.Stopped;
return(false);
}
if (delayTime != 0)
{
delayTime -= (Settings.IsIgnoreTimeScale)
? unscaledDeltaTime
: deltaTime;
if (delayTime <= 0)
{
delayTime = 0;
}
else
{
return(true);
}
}
var time = (Settings.IsIgnoreTimeScale)
? currentTime += unscaledDeltaTime
: currentTime += deltaTime;
var completed = false;
if (time >= duration)
{
time = duration;
completed = true;
}
TProperty value;
var ratio = easingFunction(time, duration);
CreateValue(ref from, ref difference, ref ratio, out value);
setter(target, ref value);
if (completed)
{
repeatCount++;
switch (Settings.LoopType)
{
case LoopType.Restart:
this.from = originalFrom;
currentTime = 0;
break;
case LoopType.CycleOnce:
if (repeatCount == 2)
{
return(false); // complete
}
goto case LoopType.Cycle;
case LoopType.Cycle: // swap from -> to
var temp = from;
from = to;
to = temp;
difference = GetDifference(from, to);
currentTime = 0;
break;
case LoopType.None:
default:
if (completedEvent != null)
{
completedEvent.OnNext(Unit.Default);
}
return(false); // finish, remove from TweenEngine
}
}
return(true);
}
