Add event handler interface to respond to events without GC allocations

Author: adamgraham

Runtime/Delegates.cs

@@ -20,11 +20,17 @@
     public delegate void TweenSetter<T,U>(T target, U value);
 
     /// <summary>
-    /// A function delegate that can be invoked during various tween events
-    /// and/or state changes, such as on complete.
+    /// A function delegate invoked during tween lifecycle events.
     /// </summary>
     public delegate void TweenCallback();
 
+    /// <summary>
+    /// A function delegate invoked during tween lifecycle events with a
+    /// provided reference to the tween that invoked the event.
+    /// </summary>
+    /// <param name="tween">The tween that invoked the event.</param>
+    public delegate void TweenReferenceCallback(Tween tween);
+
     /// <summary>
     /// A function delegate that interpolates the value between
     /// <paramref name="a"/> and <paramref name="b"/> by <paramref name="t"/>.

Runtime/ITweenEventHandler.cs

@@ -0,0 +1,46 @@
+namespace Zigurous.Tweening
+{
+    /// <summary>
+    /// A type that responds to tween lifecycle events.
+    /// </summary>
+    public interface ITweenEventHandler
+    {
+        /// <summary>
+        /// An event invoked every time the tween is updated, i.e., any time the
+        /// parameter being animated is changed.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenUpdate(Tween tween);
+
+        /// <summary>
+        /// An event invoked when the tween is started.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenStart(Tween tween);
+
+        /// <summary>
+        /// An event invoked when the tween is stopped.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenStop(Tween tween);
+
+        /// <summary>
+        /// An event invoked when the tween is looped.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenLoop(Tween tween);
+
+        /// <summary>
+        /// An event invoked when the tween is completed.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenComplete(Tween tween);
+
+        /// <summary>
+        /// An event invoked when the tween is killed.
+        /// </summary>
+        /// <param name="tween">The tween that invoked the event.</param>
+        void OnTweenKill(Tween tween);
+    }
+
+}

Runtime/ITweenEventHandler.cs.meta

@@ -319,6 +319,22 @@ public static T SetAutoKill<T>(this T tween, bool autoKill = true) where T : Twe
             return tween;
         }
 
+        /// <summary>
+        /// Sets the event handler on the tween.
+        /// </summary>
+        /// <typeparam name="T">The type of the tween.</typeparam>
+        /// <param name="tween">The tween to assign the event handler to.</param>
+        /// <param name="eventHandler">The event handler to assign.</param>
+        /// <returns>The tween itself to allow for chaining.</returns>
+        public static T SetEventHandler<T>(this T tween, ITweenEventHandler eventHandler) where T : Tween
+        {
+            if (tween != null) {
+                tween.eventHandler = eventHandler;
+            }
+
+            return tween;
+        }
+
         /// <summary>
         /// Sets the callback to invoke when the tween is updated.
         /// </summary>

Runtime/PropertyChaining.cs

@@ -182,35 +182,40 @@ public bool autoKill
         }
 
         /// <summary>
-        /// The callback invoked every time the tween is updated, i.e., any time
-        /// the parameter being animated is changed.
+        /// An event handler that responds to lifecycle events of the tween.
         /// </summary>
-        public TweenCallback onUpdate;
+        public ITweenEventHandler eventHandler;
 
         /// <summary>
-        /// The callback invoked when the tween is started.
+        /// An event invoked every time the tween is updated, i.e., any time the
+        /// parameter being animated is changed.
         /// </summary>
-        public TweenCallback onStart;
+        public event TweenCallback onUpdate;
 
         /// <summary>
-        /// The callback invoked when the tween is stopped.
+        /// An event invoked when the tween is started.
         /// </summary>
-        public TweenCallback onStop;
+        public event TweenCallback onStart;
 
         /// <summary>
-        /// The callback invoked when the tween is looped.
+        /// An event invoked when the tween is stopped.
         /// </summary>
-        public TweenCallback onLoop;
+        public event TweenCallback onStop;
 
         /// <summary>
-        /// The callback invoked when the tween is completed.
+        /// An event invoked when the tween is looped.
         /// </summary>
-        public TweenCallback onComplete;
+        public event TweenCallback onLoop;
 
         /// <summary>
-        /// The callback invoked when the tween is killed.
+        /// An event invoked when the tween is completed.
         /// </summary>
-        public TweenCallback onKill;
+        public event TweenCallback onComplete;
+
+        /// <summary>
+        /// An event invoked when the tween is killed.
+        /// </summary>
+        public event TweenCallback onKill;
 
         /// <summary>
         /// Creates a new tween object.
@@ -251,6 +256,10 @@ internal void Update(float deltaTime)
                 Animate();
                 OnUpdate();
 
+                if (eventHandler != null) {
+                    eventHandler.OnTweenUpdate(this);
+                }
+
                 if (onUpdate != null) {
                     onUpdate.Invoke();
                 }
@@ -313,6 +322,10 @@ private void Start()
             {
                 OnLoop();
 
+                if (eventHandler != null) {
+                    eventHandler.OnTweenLoop(this);
+                }
+
                 if (onLoop != null) {
                     onLoop.Invoke();
                 }
@@ -321,8 +334,15 @@ private void Start()
             OnStart();
             Animate();
 
-            if (iterations == 0 && onStart != null) {
-                onStart.Invoke();
+            if (iterations == 0)
+            {
+                if (eventHandler != null) {
+                    eventHandler.OnTweenStart(this);
+                }
+
+                if (onStart != null) {
+                    onStart.Invoke();
+                }
             }
         }
 
@@ -339,6 +359,10 @@ public void Stop()
 
             OnStop();
 
+            if (eventHandler != null) {
+                eventHandler.OnTweenStop(this);
+            }
+
             if (onStop != null) {
                 onStop.Invoke();
             }
@@ -397,6 +421,10 @@ public void Complete()
             Animate();
             OnComplete();
 
+            if (eventHandler != null) {
+                eventHandler.OnTweenComplete(this);
+            }
+
             if (onComplete != null) {
                 onComplete.Invoke();
             }
@@ -421,10 +449,15 @@ public void Kill()
 
             OnKill();
 
+            if (eventHandler != null) {
+                eventHandler.OnTweenKill(this);
+            }
+
             if (onKill != null) {
                 onKill.Invoke();
             }
 
+            eventHandler = null;
             onKill = null;
             onUpdate = null;
             onStart = null;
@@ -470,6 +503,7 @@ internal void Reset()
             autoKill = Settings.autoKill;
             recyclable = Settings.recyclable;
 
+            eventHandler = null;
             onUpdate = null;
             onStart = null;
             onStop = null;