// ------------------------------------------------------------------------- // Overrides // ------------------------------------------------------------------------- public override Timeline Build() { if (isBuilt) { return(this); } duration = 0; for (int i = 0; i < children.Count; i++) { IBaseTween obj = children[i]; if (obj.GetRepeatCount() < 0) { throw new InvalidOperationException("You can't push an object with infinite repetitions in a timeline"); } obj._Build(); switch (mode) { case Timeline.Modes.SEQUENCE: { float tDelay = duration; duration += obj.GetFullDuration(); obj.delay += tDelay; break; } case Timeline.Modes.PARALLEL: { duration = Math.Max(duration, obj.GetFullDuration()); break; } } } isBuilt = true; return(this); }
/// <summary> /// Updates every tweens with a delta time ang handles the tween life-cycles /// automatically. /// </summary> /// <remarks> /// Updates every tweens with a delta time ang handles the tween life-cycles /// automatically. If a tween is finished, it will be removed from the /// manager. The delta time represents the elapsed time between now and the /// last update call. Each tween or timeline manages its local time, and adds /// this delta to its local time to update itself. /// <p/> /// Slow motion, fast motion and backward play can be easily achieved by /// tweaking this delta time. Multiply it by -1 to play the animation /// backward, or by 0.5 to play it twice slower than its normal speed. /// </remarks> public virtual void Update(float delta) { for (int i = objects.Count - 1; i >= 0; i--) { IBaseTween obj = objects[i]; if (obj.IsFinished() && obj.isAutoRemoveEnabled) { objects.RemoveAt(i); obj.Free(); } } if (!isPaused) { if (delta >= 0) { for (int i = 0, n = objects.Count; i < n; i++) { objects[i].Update(delta); } } else { for (int i = objects.Count - 1; i >= 0; i--) { objects[i].Update(delta); } } } }
protected internal override void ForceEndValues() { for (int i = 0, n = children.Count; i < n; i++) { IBaseTween obj = children[i]; obj.ForceToEnd(duration); } }
// ------------------------------------------------------------------------- // BaseTween impl. // ------------------------------------------------------------------------- protected internal override void ForceStartValues() { for (int i = children.Count - 1; i >= 0; i--) { IBaseTween obj = children[i]; obj.ForceToStart(); } }
/// <summary>Kills every tweens associated to the given target and tween type.</summary> /// <remarks> /// Kills every tweens associated to the given target and tween type. Will /// also kill every timelines containing a tween associated to the given /// target and tween type. /// </remarks> public virtual void KillTarget(object target, int tweenType) { for (int i = 0, n = objects.Count; i < n; i++) { IBaseTween obj = objects[i]; obj.KillTarget(target, tweenType); } }
/// <summary>Kills every managed tweens and timelines.</summary> /// <remarks>Kills every managed tweens and timelines.</remarks> public virtual void KillAll() { for (int i = 0, n = objects.Count; i < n; i++) { IBaseTween obj = objects[i]; obj.Kill(); } }
public override void Free() { for (int i = children.Count - 1; i >= 0; i--) { IBaseTween obj = children[i]; children.RemoveAt(i); obj.Free(); } pool.Free(this); }
public override Timeline Start() { base.Start(); for (int i = 0; i < children.Count; i++) { IBaseTween obj = children[i]; obj._Start(); } return(this); }
protected internal override bool ContainsTarget(object target, int tweenType) { for (int i = 0, n = children.Count; i < n; i++) { IBaseTween obj = children[i]; if (obj.ContainsTarget(target, tweenType)) { return(true); } } return(false); }
/// <summary> /// Returns true if the manager contains any valid interpolation associated /// to the given target object. /// </summary> /// <remarks> /// Returns true if the manager contains any valid interpolation associated /// to the given target object. /// </remarks> public virtual bool ContainsTarget(object target) { for (int i = 0, n = objects.Count; i < n; i++) { IBaseTween obj = objects[i]; if (obj.ContainsTarget(target)) { return(true); } } return(false); }
// ------------------------------------------------------------------------- // Public API // ------------------------------------------------------------------------- /// <summary>Adds a tween or timeline to the manager and starts or restarts it.</summary> /// <remarks>Adds a tween or timeline to the manager and starts or restarts it.</remarks> /// <returns>The manager, for instruction chaining.</returns> public virtual TweenManager Add(IBaseTween tween) { if (!objects.Contains(tween)) { objects.Add(tween); } if (tween.isAutoStartEnabled) { tween._Start(); } return(this); }
private static int GetTimelinesCount(IList <IBaseTween> objs) { int cnt = 0; for (int i = 0, n = objs.Count; i < n; i++) { IBaseTween obj = objs[i]; if (obj is Timeline) { cnt += 1 + GetTimelinesCount(((Timeline)obj).GetChildren()); } } return(cnt); }
/// <summary> /// Disables or enables the "auto start" mode of any tween manager for a /// particular tween or timeline. /// </summary> /// <remarks> /// Disables or enables the "auto start" mode of any tween manager for a /// particular tween or timeline. This mode is activated by default. If it /// is not enabled, add a tween or timeline to any manager won't start it /// automatically, and you'll need to call .start() manually on your object. /// </remarks> public static void SetAutoStart(IBaseTween @object, bool value) { @object.isAutoStartEnabled = value; }
// ------------------------------------------------------------------------- // Static API // ------------------------------------------------------------------------- /// <summary> /// Disables or enables the "auto remove" mode of any tween manager for a /// particular tween or timeline. /// </summary> /// <remarks> /// Disables or enables the "auto remove" mode of any tween manager for a /// particular tween or timeline. This mode is activated by default. The /// interest of desactivating it is to prevent some tweens or timelines from /// being automatically removed from a manager once they are finished. /// Therefore, if you update a manager backwards, the tweens or timelines /// will be played again, even if they were finished. /// </remarks> public static void SetAutoRemove(IBaseTween @object, bool value) { @object.isAutoRemoveEnabled = value; }
public abstract void OnEvent <T>(int type, IBaseTween source);