public override void UpdateValue(float elapsedTime)
{
this.TweenTarget.TweenedValue = Lerps.Ease(
this.EaseType,
this.FromValue,
this.ToValue,
elapsedTime,
this.Duration);
}
protected override void UpdateValue()
{
var next = Lerps.Ease(_easeType, _fromValue, _toValue, _elapsedTime, _duration);
// XXX: hack for rounding
// var delta = _toValue - next;
// if (Math.Abs(delta.X) < 1f && Math.Abs(delta.Y) < 1f) {
// next = _toValue;
// }
_target.SetTweenedValue(next);
}
/// <summary>
/// the most common type of transition seems to be one that ticks progress from 0 - 1. This method takes care of that for you
/// if your transition needs to have a _progress property ticked after the scene loads.
/// </summary>
/// <param name="duration">duration</param>
/// <param name="reverseDirection">if true, _progress will go from 1 to 0. If false, it goes form 0 to 1</param>
public IEnumerator TickEffectProgressProperty(Effect effect, float duration, EaseType easeType = EaseType.ExpoOut, bool reverseDirection = false)
{
var start = reverseDirection ? 1f : 0f;
var end = reverseDirection ? 0f : 1f;
var progressParam = effect.Parameters["_progress"];
var elapsed = 0f;
while (elapsed < duration)
{
elapsed += Time.DeltaTime;
var step = Lerps.Ease(easeType, start, end, elapsed, duration);
progressParam.SetValue(step);
yield return(null);
}
}
public override IEnumerator OnBeginTransition()
{
yield return(null);
// load up the new Scene
yield return(Core.StartCoroutine(LoadNextScene()));
var elapsed = 0f;
while (elapsed < FadeDuration)
{
elapsed += Time.DeltaTime;
_color = Lerps.Ease(FadeEaseType, ref _fromColor, ref _toColor, elapsed, FadeDuration);
yield return(null);
}
TransitionComplete();
}
/// <summary>
/// animates the letterbox in
/// </summary>
/// <returns>The in.</returns>
/// <param name="letterboxSize">Letterbox size.</param>
/// <param name="duration">Duration.</param>
/// <param name="easeType">Ease type.</param>
public IEnumerator AnimateIn(float letterboxSize, float duration = 2, EaseType easeType = EaseType.ExpoOut)
{
// wait for any current animations to complete
while (_isAnimating)
{
yield return(null);
}
_isAnimating = true;
var elapsedTime = 0f;
while (elapsedTime < duration)
{
elapsedTime += Time.DeltaTime;
this.LetterboxSize = Lerps.Ease(easeType, 0, letterboxSize, elapsedTime, duration);
yield return(null);
}
_isAnimating = false;
}
public override IEnumerator OnBeginTransition()
{
yield return(null);
// load up the new Scene
yield return(Core.StartCoroutine(LoadNextScene()));
var elapsed = 0f;
while (elapsed < Duration)
{
elapsed += Time.DeltaTime;
_destinationRect = Lerps.Ease(TransitionEaseType, ref _textureBounds, ref _finalRenderRect, elapsed, Duration);
yield return(null);
}
TransitionComplete();
}
public IEnumerator TickEffectProgressProperty(
IProgressEffect effect,
float duration,
EaseType easeType = EaseType.ExpoOut,
bool reverseDirection = false)
{
var start = reverseDirection ? 1f : 0f;
var end = reverseDirection ? 0f : 1f;
var startAt = DateTime.Now;
while ((DateTime.Now - startAt).TotalSeconds < duration)
{
var elapsed = (float)(DateTime.Now - startAt).TotalSeconds;
var step = Lerps.Ease(easeType, start, end, elapsed, duration);
effect.Progress = step;
yield return(null);
}
}
public override IEnumerator OnBeginTransition()
{
yield return(null);
var elapsed = 0f;
while (elapsed < Duration)
{
elapsed += Time.DeltaTime;
_renderScale = Lerps.Ease(ScaleEaseType, MaxScale, MinScale, elapsed, Duration);
_renderRotation = Lerps.Ease(RotationEaseType, MinRotation, MaxRotation, elapsed, Duration);
yield return(null);
}
// load up the new Scene
yield return(Core.StartCoroutine(LoadNextScene()));
// dispose of our previousSceneRender. We dont need it anymore.
PreviousSceneRender.Dispose();
PreviousSceneRender = null;
yield return(Coroutine.WaitForSeconds(DelayBeforeMaskOut));
elapsed = 0f;
while (elapsed < Duration)
{
elapsed += Time.DeltaTime;
_renderScale = Lerps.Ease(EaseHelper.OppositeEaseType(ScaleEaseType), MinScale, MaxScale, elapsed,
Duration);
_renderRotation = Lerps.Ease(EaseHelper.OppositeEaseType(RotationEaseType), MaxRotation, MinRotation,
elapsed, Duration);
yield return(null);
}
TransitionComplete();
}
public override IEnumerator OnBeginTransition()
{
var startAt = DateTime.Now;
while ((DateTime.Now - startAt).TotalSeconds < this.FadeOutDuration)
{
var elapsed = (float)(DateTime.Now - startAt).TotalSeconds;
this.color = Lerps.Ease(
this.FadeEaseType,
ref this.fromColor,
ref this.toColor,
elapsed,
this.FadeOutDuration);
yield return(null);
}
this.SetNextScene();
yield return(DefaultCoroutines.Wait(this.DelayBeforeFadeInDuration));
startAt = DateTime.Now;
while ((DateTime.Now - startAt).TotalSeconds < this.FadeInDuration)
{
var elapsed = (float)(DateTime.Now - startAt).TotalSeconds;
this.color = Lerps.Ease(
EaseHelper.OppositeEaseType(this.FadeEaseType),
ref this.toColor,
ref this.fromColor,
elapsed,
this.FadeInDuration);
yield return(null);
}
this.TransitionComplete();
}
public override IEnumerator OnBeginTransition()
{
yield return(null);
var startAt = DateTime.Now;
while ((DateTime.Now - startAt).TotalSeconds < this.Duration)
{
var elapsed = (float)(DateTime.Now - startAt).TotalSeconds;
this.destinationRect = Lerps.Ease(
this.TransitionEaseType,
this.PreviousSceneRender.Bounds,
this.finalRenderRect,
elapsed,
this.Duration);
yield return(null);
}
this.SetNextScene();
startAt = DateTime.Now;
while ((DateTime.Now - startAt).TotalSeconds < this.Duration)
{
var elapsed = (float)(DateTime.Now - startAt).TotalSeconds;
this.destinationRect = Lerps.Ease(
this.TransitionEaseType,
this.finalRenderRect,
this.PreviousSceneRender.Bounds,
elapsed,
this.Duration);
yield return(null);
}
this.TransitionComplete();
}
public override IEnumerator OnBeginTransition()
{
// create a single pixel texture of our fadeToColor
_overlayTexture = Graphics.CreateSingleColorTexture(1, 1, FadeToColor);
var elapsed = 0f;
while (elapsed < FadeOutDuration)
{
elapsed += Time.DeltaTime;
_color = Lerps.Ease(FadeEaseType, ref _toColor, ref _fromColor, elapsed, FadeOutDuration);
yield return(null);
}
// load up the new Scene
yield return(Core.StartCoroutine(LoadNextScene()));
// dispose of our previousSceneRender. We dont need it anymore.
PreviousSceneRender.Dispose();
PreviousSceneRender = null;
yield return(Coroutine.WaitForSeconds(DelayBeforeFadeInDuration));
elapsed = 0f;
while (elapsed < FadeInDuration)
{
elapsed += Time.DeltaTime;
_color = Lerps.Ease(EaseHelper.OppositeEaseType(FadeEaseType), ref _fromColor, ref _toColor, elapsed,
FadeInDuration);
yield return(null);
}
TransitionComplete();
_overlayTexture.Dispose();
}
protected override void UpdateValue()
{
(this as ITweenTarget <float>).SetTweenedValue((float)Lerps.Ease(_easeType, _fromValue, _toValue, _elapsedTime, _duration));
}