Added tween layers.

Author: DavidF-Dev

CHANGELOG.md

@@ -5,8 +5,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Added tween layers for controlling multiple tweens at a time.
 - Added option to tween using unscaled delta time.
-- Added WaitForTween custom yield instruction.
+- Added WaitForTween and WaitForTweenLayer as custom yield instructions.
 - Added JetBrain annotations.
 - Replaced exceptions with Debug.Warning.
 

Runtime/Tween.cs

@@ -241,6 +241,9 @@ public static Tween Create<T>([NotNull] object target, [NotNull] string property
 
         private Action _onComplete;
 
+        [NotNull]
+        private TweenLayer _layer;
+
         #endregion
 
         #region Constructors
@@ -252,6 +255,8 @@ private Tween()
             LerpFunction = null!;
             EasingFunction = null!;
             UnderlyingType = null!;
+            _layer = TweenLayer.Default;
+            _layer.AddToLayer(this);
         }
 
         #endregion
@@ -269,13 +274,40 @@ private Tween()
         /// </summary>
         [PublicAPI]
         public bool IsPaused { get; set; }
+
+        /// <summary>
+        ///     Whether the tween animation is able to update. Affected by pausing and time scale.
+        /// </summary>
+        [PublicAPI]
+        public bool IsAbleToUpdate => !IsPaused && !Layer.IsPaused && (IsUnscaled || Time.timeScale > 0f);
 
         /// <summary>
         ///     Whether the tween animation should use Time.unscaledDeltaTime.
         /// </summary>
         [PublicAPI]
         public bool IsUnscaled { get; set; }
 
+        /// <summary>
+        ///     Controlling layer that the tween is a part of.
+        /// </summary>
+        [PublicAPI, NotNull]
+        public TweenLayer Layer
+        {
+            get => _layer;
+            set
+            {
+                if (value == _layer)
+                {
+                    Debug.LogError("Failed to set tween layer: already on the specified layer.");
+                    return;
+                }
+
+                _layer.RemoveFromLayer(this);
+                _layer = value;
+                _layer.AddToLayer(this);
+            }
+        }
+
         /// <summary>
         ///     Starting value of the tween (0%).
         /// </summary>
@@ -403,7 +435,7 @@ public object GetTweenedValueAt(float progress)
         [PublicAPI, Pure]
         public override string ToString()
         {
-            return $"{StartValue} to {EndValue} over {TotalDuration} seconds{(IsActive ? $" ({GetProgress()*100:0.0}%: {CurrentValue ?? "-"}){(IsPaused ? " [Paused]" : "")}" : "")}";
+            return $"{StartValue} to {EndValue} over {TotalDuration} seconds{(IsActive ? $" ({GetProgress()*100:0.0}%: {CurrentValue ?? "-"}){(!IsAbleToUpdate ? " [Paused]" : "")}" : "")}";
         }
 
         /// <summary>
@@ -426,8 +458,8 @@ private IEnumerator Update()
             // Begin loop
             while (ElapsedTime <= TotalDuration)
             {
-                // Pause if paused (duh!)
-                while (IsPaused)
+                // Pause if unable to update
+                while (!IsAbleToUpdate)
                 {
                     yield return null;
                 }

Runtime/TweenLayer.cs

@@ -0,0 +1,126 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using UnityEngine;
+
+namespace DavidFDev.Tweening
+{
+    /// <summary>
+    ///     Control all tweens in a layer at once.
+    /// </summary>
+    public sealed class TweenLayer : IReadOnlyList<Tween>
+    {
+        #region Static fields
+        
+        [PublicAPI, NotNull]
+        public static readonly TweenLayer Default = new TweenLayer();
+        
+        #endregion
+        
+        #region Fields
+
+        [NotNull]
+        private readonly HashSet<Tween> _tweens = new HashSet<Tween>();
+
+        #endregion
+        
+        #region Properties
+
+        /// <summary>
+        ///     Whether all tween animations are paused on this layer.
+        /// </summary>
+        [PublicAPI]
+        public bool IsPaused { get; set; }
+        
+        [PublicAPI]
+        public int Count => _tweens.Count;
+        
+        [PublicAPI, NotNull]
+        public Tween this[int index] => _tweens.ElementAt(index);
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        ///     Start all tweens on this layer.
+        /// </summary>
+        /// <param name="duration">Optionally change the tween's duration to a new value or, if null, remain the same.</param>
+        [PublicAPI]
+        public void StartAll(float? duration = null)
+        {
+            foreach (var tween in _tweens)
+            {
+                tween.Start(duration);
+            }
+        }
+        
+        /// <summary>
+        ///     Stop all tweens on this layer.
+        /// </summary>
+        [PublicAPI]
+        public void StopAll()
+        {
+            foreach (var tween in _tweens)
+            {
+                tween.Stop();
+            }
+        }
+        
+        public IEnumerator<Tween> GetEnumerator()
+        {
+            return _tweens.GetEnumerator();
+        }
+        
+        internal void AddToLayer([NotNull] Tween tween)
+        {
+            _tweens.Add(tween);
+        }
+
+        internal void RemoveFromLayer([NotNull] Tween tween)
+        {
+            _tweens.Remove(tween);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        
+        #endregion
+    }
+    
+    #region Other types
+
+    /// <summary>
+    ///     Yield instruction that waits for all tweens in a layer to finish.
+    ///     Usage: yield return new WaitForTweenLayer(...)
+    /// </summary>
+    public sealed class WaitForTweenLayer : CustomYieldInstruction
+    {
+        #region Fields
+
+        [PublicAPI, NotNull]
+        public readonly TweenLayer Layer;
+        
+        #endregion
+        
+        #region Constructors
+
+        public WaitForTweenLayer([NotNull] TweenLayer layer)
+        {
+            Layer = layer;
+        }
+        
+        #endregion
+        
+        #region Properties
+
+        public override bool keepWaiting => Layer.Any(x => x.IsActive);
+
+        #endregion
+    }
+    
+    #endregion
+}