// =================================================================================== // INTERNAL METHODS ------------------------------------------------------------------ /// <summary> /// Removes the given tween from this Sequence, /// and eventually kills the Sequence if all items have been removed. /// Used by <see cref="OverwriteManager"/> to remove overwritten tweens. /// </summary> internal void Remove(ABSTweenComponent p_tween) { if (items == null) { return; } int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween && item.twMember == p_tween) { items.RemoveAt(i); break; } } if (items.Count == 0) { if (isSequenced) { contSequence.Remove(this); } Kill(!isSequenced); } }
void InsertCallback(float p_time, TweenDelegate.TweenCallback p_callback, TweenDelegate.TweenCallbackWParms p_callbackWParms, params object[] p_callbackParms) { hasCallbacks = true; HOTSeqItem newItem = new HOTSeqItem(p_time, p_callback, p_callbackWParms, p_callbackParms); if (items == null) { items = new List <HOTSeqItem> { newItem }; } else { bool placed = false; int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { if (items[i].startTime >= p_time) { items.Insert(i, newItem); placed = true; break; } } if (!placed) { items.Add(newItem); } } _isEmpty = false; }
/// <summary> /// Returns a list of the eventual nested <see cref="Tweener"/> objects whose target is the given one, /// or an empty list if none was found. /// </summary> public List <Tweener> GetTweenersByTarget(object p_target) { List <Tweener> res = new List <Tweener>(); int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType != SeqItemType.Tween) { continue; } Tweener tweener = item.twMember as Tweener; if (tweener != null) { // Tweener if (tweener.target == p_target) { res.Add(tweener); } } else { // Sequence res.AddRange(((Sequence)item.twMember).GetTweenersByTarget(p_target)); } } return(res); }
float Prepend(IHOTweenComponent p_twMember, float p_duration) { if (items == null) { return(Insert(0, p_twMember)); } if (p_twMember != null) { HOTween.RemoveFromTweens(p_twMember); ((ABSTweenComponent)p_twMember).contSequence = this; CheckSpeedBasedTween(p_twMember); } HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(0, p_twMember as ABSTweenComponent) : new HOTSeqItem(0, p_duration)); float itemDur = newItem.duration; int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { items[i].startTime += itemDur; } items.Insert(0, newItem); _duration += itemDur; SetFullDuration(); _isEmpty = false; return(_duration); }
// =================================================================================== // HELPERS --------------------------------------------------------------------------- /// <summary> /// Fills the given list with all the plugins inside this sequence tween, /// while also looking for them recursively through inner sequences. /// Used by <c>HOTween.GetPlugins</c>. /// </summary> internal override void FillPluginsList(List <ABSTweenPlugin> p_plugs) { if (items == null) { return; } int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem itm = items[i]; if (itm.twMember == null) { continue; } Sequence sequence = itm.twMember as Sequence; if (sequence != null) { sequence.FillPluginsList(p_plugs); } else { itm.twMember.FillPluginsList(p_plugs); } } }
/// <summary> /// Returns a list of the eventual existing tweens with the given Id within this Sequence, /// nested tweens included (or an empty list if no tweens were found). /// </summary> internal override List <IHOTweenComponent> GetTweensByIntId(int p_intId) { List <IHOTweenComponent> res = new List <IHOTweenComponent>(); if (destroyed) { return(res); } if (intId == p_intId) { res.Add(this); } int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween) { res.AddRange(item.twMember.GetTweensByIntId(p_intId)); } } return(res); }
void Rewind(bool p_play) { if (!_enabled) { return; } if (items == null) { return; } Startup(); if (!_hasStarted) { OnStart(); } _isComplete = false; _isLoopingBack = false; _completedLoops = 0; _fullElapsed = _elapsed = 0; int itemsCount = items.Count - 1; for (int i = itemsCount; i > -1; --i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween) { item.twMember.Rewind(); } } // Manage OnUpdate and OnRewinded. if (_fullElapsed != prevFullElapsed) { OnUpdate(); if (_fullElapsed == 0) { OnRewinded(); } } prevFullElapsed = _fullElapsed; if (p_play) { Play(); } else { Pause(); } }
/// <summary> /// Sets the correct values in case of Incremental loop type. /// Also called by Tweener.ApplySequenceIncrement (used by Sequences during Incremental loops). /// </summary> /// <param name="p_diffIncr"> /// The difference from the previous loop increment. /// </param> internal override void SetIncremental(int p_diffIncr) { int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType != SeqItemType.Tween) { continue; } item.twMember.SetIncremental(p_diffIncr); } }
float Insert(float p_time, IHOTweenComponent p_twMember, float p_duration) { if (p_twMember != null) { HOTween.RemoveFromTweens(p_twMember); ((ABSTweenComponent)p_twMember).contSequence = this; CheckSpeedBasedTween(p_twMember); } HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(p_time, p_twMember as ABSTweenComponent) : new HOTSeqItem(p_time, p_duration)); if (items == null) { items = new List <HOTSeqItem> { newItem }; _duration = newItem.startTime + newItem.duration; SetFullDuration(); _isEmpty = false; return(_duration); } bool placed = false; int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { if (items[i].startTime >= p_time) { items.Insert(i, newItem); placed = true; break; } } if (!placed) { items.Add(newItem); } _duration = Mathf.Max(newItem.startTime + newItem.duration, _duration); SetFullDuration(); _isEmpty = false; return(_duration); }
/// <summary> /// Returns <c>true</c> if the tween with the given int id is currently involved in a running tween or sequence. /// </summary> /// <param name="p_id"> /// The id to check for. /// </param> public override bool IsTweening(int p_id) { if (!_enabled || items == null) { return(false); } int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween && item.twMember.IsTweening(p_id)) { return(true); } } return(false); }
/// <summary> /// Returns a list of all the targets of this Sequence, or NULL if there are none. /// </summary> /// <returns>A list of all the targets of this Sequence, or NULL if there are none.</returns> public override List <object> GetTweenTargets() { if (items == null) { return(null); } List <object> targets = new List <object>(); int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween) { targets.AddRange(item.twMember.GetTweenTargets()); } } return(targets); }
/// <summary> /// Returns <c>true</c> if the given target is linked to a tween of this Sequence (running or not, taking into account also nested tweens). /// </summary> /// <param name="p_target"> /// The target to check. /// </param> /// <returns> /// A value of <c>true</c> if the given target is linked to a tween of this Sequence (running or not, taking into account also nested tweens). /// </returns> public override bool IsLinkedTo(object p_target) { if (items == null) { return(false); } int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween && item.twMember.IsLinkedTo(p_target)) { return(true); } } return(false); }
// =================================================================================== // METHODS --------------------------------------------------------------------------- /// <summary> /// Kills this Sequence and cleans it. /// </summary> /// <param name="p_autoRemoveFromHOTween"> /// If <c>true</c> also calls <c>HOTween.Kill(this)</c> to remove it from HOTween. /// Set internally to <c>false</c> when I already know that HOTween is going to remove it. /// </param> internal override void Kill(bool p_autoRemoveFromHOTween) { if (_destroyed) { return; } if (items != null) { int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { HOTSeqItem item = items[i]; if (item.seqItemType == SeqItemType.Tween) { item.twMember.Kill(false); } } items = null; } base.Kill(p_autoRemoveFromHOTween); }
float Append(IHOTweenComponent p_twMember, float p_duration) { if (items == null) { return(p_twMember != null ? Insert(0, p_twMember) : Insert(0, null, p_duration)); } if (p_twMember != null) { HOTween.RemoveFromTweens(p_twMember); ((ABSTweenComponent)p_twMember).contSequence = this; CheckSpeedBasedTween(p_twMember); } HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(_duration, p_twMember as ABSTweenComponent) : new HOTSeqItem(_duration, p_duration)); items.Add(newItem); _duration += newItem.duration; SetFullDuration(); _isEmpty = false; return(_duration); }
void InsertCallback(float p_time, TweenDelegate.TweenCallback p_callback, TweenDelegate.TweenCallbackWParms p_callbackWParms, params object[] p_callbackParms) { hasCallbacks = true; HOTSeqItem newItem = new HOTSeqItem(p_time, p_callback, p_callbackWParms, p_callbackParms); if (items == null) { items = new List<HOTSeqItem> { newItem }; } else { bool placed = false; int itemsCount = items.Count; for (int i = 0; i < itemsCount; ++i) { if (items[i].startTime >= p_time) { items.Insert(i, newItem); placed = true; break; } } if (!placed) items.Add(newItem); } _isEmpty = false; }