Prevent errors when tweens are created while unloading

adamgraham · adamgraham · commit ad6262178d86 · 2022-05-11T14:22:26.000-05:00
diff --git a/Runtime/PropertyChaining.cs b/Runtime/PropertyChaining.cs
@@ -19,11 +19,12 @@ public static class PropertyChaining
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetTarget<T>(this T tween, Component target) where T: Tween
         {
-            if (target != null)
+            if (tween != null && target != null)
             {
                 tween.id = target.GetHashCode();
                 tween.sceneIndex = target.gameObject.scene.buildIndex;
             }
+
             return tween;
         }
 
@@ -37,11 +38,12 @@ public static T SetTarget<T>(this T tween, Component target) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetTarget<T>(this T tween, GameObject target) where T: Tween
         {
-            if (target != null)
+            if (tween != null && target != null)
             {
                 tween.id = target.GetHashCode();
                 tween.sceneIndex = target.scene.buildIndex;
             }
+
             return tween;
         }
 
@@ -54,7 +56,10 @@ public static T SetTarget<T>(this T tween, GameObject target) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetId<T>(this T tween, int id) where T: Tween
         {
-            tween.id = id;
+            if (tween != null) {
+                tween.id = id;
+            }
+
             return tween;
         }
 
@@ -67,7 +72,10 @@ public static T SetId<T>(this T tween, int id) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetSceneIndex<T>(this T tween, int index) where T: Tween
         {
-            tween.sceneIndex = index;
+            if (tween != null) {
+                tween.sceneIndex = index;
+            }
+
             return tween;
         }
 
@@ -80,7 +88,10 @@ public static T SetSceneIndex<T>(this T tween, int index) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetEase<T>(this T tween, Ease ease) where T: Tween
         {
-            tween.ease = ease;
+            if (tween != null) {
+                tween.ease = ease;
+            }
+
             return tween;
         }
 
@@ -93,7 +104,10 @@ public static T SetEase<T>(this T tween, Ease ease) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetDuration<T>(this T tween, float duration) where T: Tween
         {
-            tween.duration = duration;
+            if (tween != null) {
+                tween.duration = duration;
+            }
+
             return tween;
         }
 
@@ -106,7 +120,10 @@ public static T SetDuration<T>(this T tween, float duration) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetDelay<T>(this T tween, float delay) where T: Tween
         {
-            tween.delay = delay;
+            if (tween != null) {
+                tween.delay = delay;
+            }
+
             return tween;
         }
 
@@ -120,8 +137,12 @@ public static T SetDelay<T>(this T tween, float delay) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetLoops<T>(this T tween, int loops, LoopType loopType = LoopType.Restart) where T: Tween
         {
-            tween.loops = loops;
-            tween.loopType = loopType;
+            if (tween != null)
+            {
+                tween.loops = loops;
+                tween.loopType = loopType;
+            }
+
             return tween;
         }
 
@@ -134,7 +155,10 @@ public static T SetLoops<T>(this T tween, int loops, LoopType loopType = LoopTyp
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetReversed<T>(this T tween, bool reversed = true) where T: Tween
         {
-            tween.reversed = reversed;
+            if (tween != null) {
+                tween.reversed = reversed;
+            }
+
             return tween;
         }
 
@@ -147,7 +171,10 @@ public static T SetReversed<T>(this T tween, bool reversed = true) where T: Twee
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetSnapping<T>(this T tween, bool snapping = true) where T: Tween
         {
-            tween.snapping = snapping;
+            if (tween != null) {
+                tween.snapping = snapping;
+            }
+
             return tween;
         }
 
@@ -160,7 +187,10 @@ public static T SetSnapping<T>(this T tween, bool snapping = true) where T: Twee
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetRecyclable<T>(this T tween, bool recyclable) where T: Tween
         {
-            tween.recyclable = recyclable;
+            if (tween != null) {
+                tween.recyclable = recyclable;
+            }
+
             return tween;
         }
 
@@ -173,7 +203,10 @@ public static T SetRecyclable<T>(this T tween, bool recyclable) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetAutoStart<T>(this T tween, bool autoStart) where T: Tween
         {
-            tween.autoStart = autoStart;
+            if (tween != null) {
+                tween.autoStart = autoStart;
+            }
+
             return tween;
         }
 
@@ -186,7 +219,10 @@ public static T SetAutoStart<T>(this T tween, bool autoStart) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T SetAutoKill<T>(this T tween, bool autoKill) where T: Tween
         {
-            tween.autoKill = autoKill;
+            if (tween != null) {
+                tween.autoKill = autoKill;
+            }
+
             return tween;
         }
 
@@ -199,7 +235,10 @@ public static T SetAutoKill<T>(this T tween, bool autoKill) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnUpdate<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onUpdate += callback;
+            if (tween != null) {
+                tween.onUpdate += callback;
+            }
+
             return tween;
         }
 
@@ -212,7 +251,10 @@ public static T OnUpdate<T>(this T tween, TweenCallback callback) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnStart<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onStart += callback;
+            if (tween != null) {
+                tween.onStart += callback;
+            }
+
             return tween;
         }
 
@@ -225,7 +267,10 @@ public static T OnStart<T>(this T tween, TweenCallback callback) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnStop<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onStop += callback;
+            if (tween != null) {
+                tween.onStop += callback;
+            }
+
             return tween;
         }
 
@@ -238,7 +283,10 @@ public static T OnStop<T>(this T tween, TweenCallback callback) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnLoop<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onLoop += callback;
+            if (tween != null) {
+                tween.onLoop += callback;
+            }
+
             return tween;
         }
 
@@ -251,7 +299,10 @@ public static T OnLoop<T>(this T tween, TweenCallback callback) where T: Tween
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnComplete<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onComplete += callback;
+            if (tween != null) {
+                tween.onComplete += callback;
+            }
+
             return tween;
         }
 
@@ -264,7 +315,10 @@ public static T OnComplete<T>(this T tween, TweenCallback callback) where T: Twe
         /// <returns>The tween itself to allow for chaining.</returns>
         public static T OnKill<T>(this T tween, TweenCallback callback) where T: Tween
         {
-            tween.onKill += callback;
+            if (tween != null) {
+                tween.onKill += callback;
+            }
+
             return tween;
         }
 
diff --git a/Runtime/Tween.cs b/Runtime/Tween.cs
@@ -220,7 +220,10 @@ public bool autoKill
         public Tween()
         {
             Reset();
-            TweenManager.Instance.Track(this);
+
+            if (!TweenManager.Unloading) {
+                TweenManager.Instance.Track(this);
+            }
         }
 
         /// <summary>
diff --git a/Runtime/TweenManager.cs b/Runtime/TweenManager.cs
@@ -45,6 +45,7 @@ internal static TweenManager Instance
         }
 
         public static bool HasInstance => instance != null;
+        internal static bool Unloading => isUnloading;
 
         internal List<Tween> tweens = new List<Tween>(Settings.initialCapacity);
 
diff --git a/Runtime/Tweening.cs b/Runtime/Tweening.cs
@@ -206,13 +206,18 @@ public static Tween To(TweenGetter<Color> getter, TweenSetter<Color> setter, Col
         /// <returns>A new tween that animates the parameter.</returns>
         public static Tween To<T>(Interpolater<T> interpolater, TweenGetter<T> getter, TweenSetter<T> setter, T endValue, float duration)
         {
+            if (TweenManager.Unloading) {
+                return null;
+            }
+
             Tweener<T> tween = TweenManager.Instance.BuildTweener<T>();
             tween.interpolater = interpolater;
             tween.getter = getter;
             tween.setter = setter;
             tween.endValue = endValue;
             tween.duration = duration;
             tween.reversed = false;
+
             return tween;
         }
 
@@ -373,13 +378,18 @@ public static Tween From(TweenGetter<Color> getter, TweenSetter<Color> setter, C
         /// <returns>A new tween that animates the parameter.</returns>
         public static Tween From<T>(Interpolater<T> interpolater, TweenGetter<T> getter, TweenSetter<T> setter, T endValue, float duration)
         {
+            if (TweenManager.Unloading) {
+                return null;
+            }
+
             Tweener<T> tween = TweenManager.Instance.BuildTweener<T>();
             tween.interpolater = interpolater;
             tween.getter = getter;
             tween.setter = setter;
             tween.endValue = endValue;
             tween.duration = duration;
             tween.reversed = true;
+
             return tween;
         }
 
@@ -389,7 +399,11 @@ public static Tween From<T>(Interpolater<T> interpolater, TweenGetter<T> getter,
         /// <returns>The new tween sequence.</returns>
         public static Sequence Sequence()
         {
-            return TweenManager.Instance.BuildSequence();
+            if (!TweenManager.Unloading) {
+                return TweenManager.Instance.BuildSequence();
+            } else {
+                return null;
+            }
         }
 
         /// <summary>
@@ -399,6 +413,10 @@ public static Sequence Sequence()
         /// <returns>The new tween sequence.</returns>
         public static Sequence Sequence(params Tween[] tweens)
         {
+            if (TweenManager.Unloading) {
+                return null;
+            }
+
             Sequence sequence = TweenManager.Instance.BuildSequence();
 
             if (tweens != null && tweens.Length > 0) {

Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,12 @@ public static class PropertyChaining`
`19`	`19`	`/// <returns>The tween itself to allow for chaining.</returns>`
`20`	`20`	`public static T SetTarget<T>(this T tween, Component target) where T: Tween`
`21`	`21`	`{`
`22`		`- if (target != null)`
	`22`	`+ if (tween != null && target != null)`
`23`	`23`	`{`
`24`	`24`	`tween.id = target.GetHashCode();`
`25`	`25`	`tween.sceneIndex = target.gameObject.scene.buildIndex;`
`26`	`26`	`}`
	`27`	`+`
`27`	`28`	`return tween;`
`28`	`29`	`}`
`29`	`30`
`@@ -37,11 +38,12 @@ public static T SetTarget<T>(this T tween, Component target) where T: Tween`
`37`	`38`	`/// <returns>The tween itself to allow for chaining.</returns>`
`38`	`39`	`public static T SetTarget<T>(this T tween, GameObject target) where T: Tween`
`39`	`40`	`{`
`40`		`- if (target != null)`
	`41`	`+ if (tween != null && target != null)`
`41`	`42`	`{`
`42`	`43`	`tween.id = target.GetHashCode();`
`43`	`44`	`tween.sceneIndex = target.scene.buildIndex;`
`44`	`45`	`}`
	`46`	`+`
`45`	`47`	`return tween;`
`46`	`48`	`}`
`47`	`49`
`@@ -54,7 +56,10 @@ public static T SetTarget<T>(this T tween, GameObject target) where T: Tween`
`54`	`56`	`/// <returns>The tween itself to allow for chaining.</returns>`
`55`	`57`	`public static T SetId<T>(this T tween, int id) where T: Tween`
`56`	`58`	`{`
`57`		`- tween.id = id;`
	`59`	`+ if (tween != null) {`
	`60`	`+ tween.id = id;`
	`61`	`+ }`
	`62`	`+`
`58`	`63`	`return tween;`
`59`	`64`	`}`
`60`	`65`
`@@ -67,7 +72,10 @@ public static T SetId<T>(this T tween, int id) where T: Tween`
`67`	`72`	`/// <returns>The tween itself to allow for chaining.</returns>`
`68`	`73`	`public static T SetSceneIndex<T>(this T tween, int index) where T: Tween`
`69`	`74`	`{`
`70`		`- tween.sceneIndex = index;`
	`75`	`+ if (tween != null) {`
	`76`	`+ tween.sceneIndex = index;`
	`77`	`+ }`
	`78`	`+`
`71`	`79`	`return tween;`
`72`	`80`	`}`
`73`	`81`
`@@ -80,7 +88,10 @@ public static T SetSceneIndex<T>(this T tween, int index) where T: Tween`
`80`	`88`	`/// <returns>The tween itself to allow for chaining.</returns>`
`81`	`89`	`public static T SetEase<T>(this T tween, Ease ease) where T: Tween`
`82`	`90`	`{`
`83`		`- tween.ease = ease;`
	`91`	`+ if (tween != null) {`
	`92`	`+ tween.ease = ease;`
	`93`	`+ }`
	`94`	`+`
`84`	`95`	`return tween;`
`85`	`96`	`}`
`86`	`97`
`@@ -93,7 +104,10 @@ public static T SetEase<T>(this T tween, Ease ease) where T: Tween`
`93`	`104`	`/// <returns>The tween itself to allow for chaining.</returns>`
`94`	`105`	`public static T SetDuration<T>(this T tween, float duration) where T: Tween`
`95`	`106`	`{`
`96`		`- tween.duration = duration;`
	`107`	`+ if (tween != null) {`
	`108`	`+ tween.duration = duration;`
	`109`	`+ }`
	`110`	`+`
`97`	`111`	`return tween;`
`98`	`112`	`}`
`99`	`113`
`@@ -106,7 +120,10 @@ public static T SetDuration<T>(this T tween, float duration) where T: Tween`
`106`	`120`	`/// <returns>The tween itself to allow for chaining.</returns>`
`107`	`121`	`public static T SetDelay<T>(this T tween, float delay) where T: Tween`
`108`	`122`	`{`
`109`		`- tween.delay = delay;`
	`123`	`+ if (tween != null) {`
	`124`	`+ tween.delay = delay;`
	`125`	`+ }`
	`126`	`+`
`110`	`127`	`return tween;`
`111`	`128`	`}`
`112`	`129`
`@@ -120,8 +137,12 @@ public static T SetDelay<T>(this T tween, float delay) where T: Tween`
`120`	`137`	`/// <returns>The tween itself to allow for chaining.</returns>`
`121`	`138`	`public static T SetLoops<T>(this T tween, int loops, LoopType loopType = LoopType.Restart) where T: Tween`
`122`	`139`	`{`
`123`		`- tween.loops = loops;`
`124`		`- tween.loopType = loopType;`
	`140`	`+ if (tween != null)`
	`141`	`+ {`
	`142`	`+ tween.loops = loops;`
	`143`	`+ tween.loopType = loopType;`
	`144`	`+ }`
	`145`	`+`
`125`	`146`	`return tween;`
`126`	`147`	`}`
`127`	`148`
`@@ -134,7 +155,10 @@ public static T SetLoops<T>(this T tween, int loops, LoopType loopType = LoopTyp`
`134`	`155`	`/// <returns>The tween itself to allow for chaining.</returns>`
`135`	`156`	`public static T SetReversed<T>(this T tween, bool reversed = true) where T: Tween`
`136`	`157`	`{`
`137`		`- tween.reversed = reversed;`
	`158`	`+ if (tween != null) {`
	`159`	`+ tween.reversed = reversed;`
	`160`	`+ }`
	`161`	`+`
`138`	`162`	`return tween;`
`139`	`163`	`}`
`140`	`164`
`@@ -147,7 +171,10 @@ public static T SetReversed<T>(this T tween, bool reversed = true) where T: Twee`
`147`	`171`	`/// <returns>The tween itself to allow for chaining.</returns>`
`148`	`172`	`public static T SetSnapping<T>(this T tween, bool snapping = true) where T: Tween`
`149`	`173`	`{`
`150`		`- tween.snapping = snapping;`
	`174`	`+ if (tween != null) {`
	`175`	`+ tween.snapping = snapping;`
	`176`	`+ }`
	`177`	`+`
`151`	`178`	`return tween;`
`152`	`179`	`}`
`153`	`180`
`@@ -160,7 +187,10 @@ public static T SetSnapping<T>(this T tween, bool snapping = true) where T: Twee`
`160`	`187`	`/// <returns>The tween itself to allow for chaining.</returns>`
`161`	`188`	`public static T SetRecyclable<T>(this T tween, bool recyclable) where T: Tween`
`162`	`189`	`{`
`163`		`- tween.recyclable = recyclable;`
	`190`	`+ if (tween != null) {`
	`191`	`+ tween.recyclable = recyclable;`
	`192`	`+ }`
	`193`	`+`
`164`	`194`	`return tween;`
`165`	`195`	`}`
`166`	`196`
`@@ -173,7 +203,10 @@ public static T SetRecyclable<T>(this T tween, bool recyclable) where T: Tween`
`173`	`203`	`/// <returns>The tween itself to allow for chaining.</returns>`
`174`	`204`	`public static T SetAutoStart<T>(this T tween, bool autoStart) where T: Tween`
`175`	`205`	`{`
`176`		`- tween.autoStart = autoStart;`
	`206`	`+ if (tween != null) {`
	`207`	`+ tween.autoStart = autoStart;`
	`208`	`+ }`
	`209`	`+`
`177`	`210`	`return tween;`
`178`	`211`	`}`
`179`	`212`
`@@ -186,7 +219,10 @@ public static T SetAutoStart<T>(this T tween, bool autoStart) where T: Tween`
`186`	`219`	`/// <returns>The tween itself to allow for chaining.</returns>`
`187`	`220`	`public static T SetAutoKill<T>(this T tween, bool autoKill) where T: Tween`
`188`	`221`	`{`
`189`		`- tween.autoKill = autoKill;`
	`222`	`+ if (tween != null) {`
	`223`	`+ tween.autoKill = autoKill;`
	`224`	`+ }`
	`225`	`+`
`190`	`226`	`return tween;`
`191`	`227`	`}`
`192`	`228`
`@@ -199,7 +235,10 @@ public static T SetAutoKill<T>(this T tween, bool autoKill) where T: Tween`
`199`	`235`	`/// <returns>The tween itself to allow for chaining.</returns>`
`200`	`236`	`public static T OnUpdate<T>(this T tween, TweenCallback callback) where T: Tween`
`201`	`237`	`{`
`202`		`- tween.onUpdate += callback;`
	`238`	`+ if (tween != null) {`
	`239`	`+ tween.onUpdate += callback;`
	`240`	`+ }`
	`241`	`+`
`203`	`242`	`return tween;`
`204`	`243`	`}`
`205`	`244`
`@@ -212,7 +251,10 @@ public static T OnUpdate<T>(this T tween, TweenCallback callback) where T: Tween`
`212`	`251`	`/// <returns>The tween itself to allow for chaining.</returns>`
`213`	`252`	`public static T OnStart<T>(this T tween, TweenCallback callback) where T: Tween`
`214`	`253`	`{`
`215`		`- tween.onStart += callback;`
	`254`	`+ if (tween != null) {`
	`255`	`+ tween.onStart += callback;`
	`256`	`+ }`
	`257`	`+`
`216`	`258`	`return tween;`
`217`	`259`	`}`
`218`	`260`
`@@ -225,7 +267,10 @@ public static T OnStart<T>(this T tween, TweenCallback callback) where T: Tween`
`225`	`267`	`/// <returns>The tween itself to allow for chaining.</returns>`
`226`	`268`	`public static T OnStop<T>(this T tween, TweenCallback callback) where T: Tween`
`227`	`269`	`{`
`228`		`- tween.onStop += callback;`
	`270`	`+ if (tween != null) {`
	`271`	`+ tween.onStop += callback;`
	`272`	`+ }`
	`273`	`+`
`229`	`274`	`return tween;`
`230`	`275`	`}`
`231`	`276`
`@@ -238,7 +283,10 @@ public static T OnStop<T>(this T tween, TweenCallback callback) where T: Tween`
`238`	`283`	`/// <returns>The tween itself to allow for chaining.</returns>`
`239`	`284`	`public static T OnLoop<T>(this T tween, TweenCallback callback) where T: Tween`
`240`	`285`	`{`
`241`		`- tween.onLoop += callback;`
	`286`	`+ if (tween != null) {`
	`287`	`+ tween.onLoop += callback;`
	`288`	`+ }`
	`289`	`+`
`242`	`290`	`return tween;`
`243`	`291`	`}`
`244`	`292`
`@@ -251,7 +299,10 @@ public static T OnLoop<T>(this T tween, TweenCallback callback) where T: Tween`
`251`	`299`	`/// <returns>The tween itself to allow for chaining.</returns>`
`252`	`300`	`public static T OnComplete<T>(this T tween, TweenCallback callback) where T: Tween`
`253`	`301`	`{`
`254`		`- tween.onComplete += callback;`
	`302`	`+ if (tween != null) {`
	`303`	`+ tween.onComplete += callback;`
	`304`	`+ }`
	`305`	`+`
`255`	`306`	`return tween;`
`256`	`307`	`}`
`257`	`308`
`@@ -264,7 +315,10 @@ public static T OnComplete<T>(this T tween, TweenCallback callback) where T: Twe`
`264`	`315`	`/// <returns>The tween itself to allow for chaining.</returns>`
`265`	`316`	`public static T OnKill<T>(this T tween, TweenCallback callback) where T: Tween`
`266`	`317`	`{`
`267`		`- tween.onKill += callback;`
	`318`	`+ if (tween != null) {`
	`319`	`+ tween.onKill += callback;`
	`320`	`+ }`
	`321`	`+`
`268`	`322`	`return tween;`
`269`	`323`	`}`
`270`	`324`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,10 @@ public bool autoKill`
`220`	`220`	`public Tween()`
`221`	`221`	`{`
`222`	`222`	`Reset();`
`223`		`- TweenManager.Instance.Track(this);`
	`223`	`+`
	`224`	`+ if (!TweenManager.Unloading) {`
	`225`	`+ TweenManager.Instance.Track(this);`
	`226`	`+ }`
`224`	`227`	`}`
`225`	`228`
`226`	`229`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ internal static TweenManager Instance`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public static bool HasInstance => instance != null;`
	`48`	`+ internal static bool Unloading => isUnloading;`
`48`	`49`
`49`	`50`	`internal List<Tween> tweens = new List<Tween>(Settings.initialCapacity);`
`50`	`51`