com.kyrylokuzyk.primetween 1.3.0 → 1.3.2

package/Editor/CodeGenerator.asset

@@ -946,6 +946,17 @@ MonoBehaviour:
     dependency: 9
     placeInGlobalScope: 0
     generateOnlyOverloads: 0
+  - description: Color_VisualElement
+    methodName: Color
+    targetType: UnityEngine.UIElements.VisualElement
+    propertyType: 2
+    propertyName: 
+    propertyGetter: style.color.value
+    propertySetter: style.color = val
+    dotweenMethodName: 
+    dependency: 9
+    placeInGlobalScope: 0
+    generateOnlyOverloads: 0
   - description: VisualElementBackgroundColor_VisualElement
     methodName: VisualElementBackgroundColor
     targetType: UnityEngine.UIElements.VisualElement
@@ -957,6 +968,28 @@ MonoBehaviour:
     dependency: 9
     placeInGlobalScope: 0
     generateOnlyOverloads: 0
+  - description: VisualElementOpacity_VisualElement
+    methodName: VisualElementOpacity
+    targetType: UnityEngine.UIElements.VisualElement
+    propertyType: 1
+    propertyName: 
+    propertyGetter: style.opacity.value
+    propertySetter: style.opacity = val
+    dotweenMethodName: 
+    dependency: 9
+    placeInGlobalScope: 0
+    generateOnlyOverloads: 0
+  - description: Alpha_VisualElement
+    methodName: Alpha
+    targetType: UnityEngine.UIElements.VisualElement
+    propertyType: 1
+    propertyName: 
+    propertyGetter: style.opacity.value
+    propertySetter: style.opacity = val
+    dotweenMethodName: 
+    dependency: 9
+    placeInGlobalScope: 0
+    generateOnlyOverloads: 0
   - description: OffsetMin_RectTransform
     methodName: OffsetMin
     targetType: UnityEngine.RectTransform

package/Editor/CodeGenerator.cs

@@ -248,9 +248,14 @@ namespace PrimeTween {
         { // generate enums
             foreach (var group in methodsData.GroupBy(_ => _.dependency)) {
                 foreach (var data in group) {
-                    text += "        ";
-                    var enumName = GetTweenTypeEnumName(data);
+                    string enumName = GetTweenTypeEnumName(data);
+                    if (methodDataToEnumName.Values.Contains(enumName)) {
+                        // skip duplicates like VisualElementColor_VisualElement / Color_VisualElement and VisualElementOpacity_VisualElement / Alpha_VisualElement
+                        Debug.Log($"skip duplicate {enumName}");
+                        continue;
+                    }
                     methodDataToEnumName.Add(data, enumName);
+                    text += "        ";
                     text += enumName;
                     text += ",\n";
                 }
@@ -281,7 +286,10 @@ internal static class Utils {
                     }
                 }
                 foreach (var data in group) {
-                    utilsText += $"            case TweenType.{methodDataToEnumName[data]}:\n";
+                    if (!methodDataToEnumName.TryGetValue(data, out string enumName)) {
+                        continue;
+                    }
+                    utilsText += $"            case TweenType.{enumName}:\n";
                     utilsText += $"                return (PropType.{data.propertyType}, typeof({getTypeByName(data.targetType).FullName}));\n";
                 }
                 if (shouldWrapInDefine(dependency)) {
@@ -348,6 +356,12 @@ internal static class Utils {
     static string GetTweenTypeEnumName(MethodGenerationData data) {
         string result = "";
         var dependency = data.dependency;
+        if (dependency == Dependency.UI_ELEMENTS_MODULE_INSTALLED) {
+            if (data.methodName == "Alpha") {
+                return "VisualElementOpacity";
+            }
+        }
+
         if (dependency != Dependency.None) {
             result += getMethodPrefix(dependency);
         }
@@ -355,7 +369,7 @@ internal static class Utils {
             result += "VisualElement";
         }
         result += data.methodName;
-        if ((data.methodName == "Alpha" || data.methodName == "Color") && data.dependency == Dependency.UNITY_UGUI_INSTALLED) {
+        if ((data.methodName == "Alpha" || data.methodName == "Color") && dependency == Dependency.UNITY_UGUI_INSTALLED) {
             result += getTypeByName(data.targetType).Name;
         } else if (data.methodName == "Scale" && data.propertyType == PropType.Float) {
             result += "Uniform";

package/Editor/Tests/EditModeTests.cs

@@ -9,6 +9,10 @@ using AssertionException = UnityEngine.Assertions.AssertionException;
 public class EditModeTests {
     [Test]
     public void TestEditMode() {
+        Tween.StopAll();
+        Assert.AreEqual(0, PrimeTweenManager.Instance.tweensCount);
+        PrimeTweenConfig.warnEndValueEqualsCurrent = false;
+        PrimeTweenConfig.warnZeroDuration = false;
         expectError();
         Tween.Custom(0, 1, 1, delegate {});
         var go = new GameObject();
@@ -21,6 +25,7 @@ public class EditModeTests {
             Tween.Delay(0);
             expectError();
             Tween.CompleteAll();
+            PrimeTweenConfig.warnEndValueEqualsCurrent = true;
             expectError();
             Tween.StopAll();
             expectError();
@@ -38,17 +43,18 @@ public class EditModeTests {
             expectError();
             Tween.GetTweensCount();
             expectError();
-            Sequence.Create(new Tween());
+            Sequence.Create(Tween.Delay(0.01f));
 
             TweenSettings.ValidateCustomCurveKeyframes(AnimationCurve.Linear(0, 0, 1, 1));
             PrimeTweenConfig.SetTweensCapacity(10);
-            Assert.Throws<AssertionException>(() => PrimeTweenConfig.defaultEase = Ease.InCirc);
+            Assert.DoesNotThrow(() => PrimeTweenConfig.defaultEase = Ease.InCirc);
         }
         Object.DestroyImmediate(go);
         void expectError() {
-            LogAssert.Expect(LogType.Warning, Constants.editModeWarning);
         }
         LogAssert.NoUnexpectedReceived();
+        PrimeTweenConfig.warnEndValueEqualsCurrent = true;
+        PrimeTweenConfig.warnZeroDuration = true;
     }
 
     #if PRIME_TWEEN_SAFETY_CHECKS

package/Runtime/Easing.cs

@@ -166,11 +166,6 @@ namespace PrimeTween {
                     Debug.LogError("Ease.Custom is an invalid type for Easing.Evaluate(). Please choose another Ease type instead.");
                     return interpolationFactor;
                 case Ease.Default:
-                    #if UNITY_EDITOR
-                    if (Constants.warnNoInstance) {
-                        return interpolationFactor;
-                    }
-                    #endif
                     return StandardEasing.Evaluate(interpolationFactor, PrimeTweenManager.Instance.defaultEase);
                 default:
                     return StandardEasing.Evaluate(interpolationFactor, ease);

package/Runtime/Internal/Constants.cs

@@ -1,3 +1,4 @@
+using System;
 using JetBrains.Annotations;
 using UnityEngine;
 using T = PrimeTween.TweenSettings<float>;
@@ -49,21 +50,5 @@ namespace PrimeTween {
         internal const string nestSequenceTwiceError = "Sequence can be nested in other sequence only once.";
         internal const string nestTweenTwiceError = "A tween can be added to a sequence only once and can only belong to one sequence.";
         internal const string addDeadTweenToSequenceError = "It's not allowed to add 'dead' tweens to a sequence.";
-
-        #if UNITY_EDITOR
-        internal const string editModeWarning = "Please don't call PrimeTween's API in Edit mode (while the scene is not playing).";
-
-        internal static bool warnNoInstance {
-            get {
-                if (noInstance) {
-                    Debug.LogWarning(editModeWarning);
-                    return true;
-                }
-                return false;
-            }
-        }
-
-        internal static bool noInstance => ReferenceEquals(null, PrimeTweenManager.Instance);
-        #endif
     }
 }

package/Runtime/Internal/PrimeTweenManager.cs

@@ -15,9 +15,41 @@ using UnityEditor;
 namespace PrimeTween {
     [AddComponentMenu("")]
     internal class PrimeTweenManager : MonoBehaviour {
-        internal static PrimeTweenManager Instance;
+        #if UNITY_EDITOR || SAFETY_CHECKS
+            internal static PrimeTweenManager _instance;
+            internal static PrimeTweenManager Instance {
+                get {
+                    if (!HasInstance) {
+                        if (Application.isEditor) {
+                            CreateInstance();
+                            _instance.gameObject.hideFlags = HideFlags.HideAndDontSave;
+                        } else {
+                            const string error = nameof(PrimeTweenManager) + " is not created yet. Please add the 'PRIME_TWEEN_EXPERIMENTAL' define to your project, then use '" + nameof(PrimeTweenConfig) + "." + nameof(PrimeTweenConfig.ManualInitialize) + "()' to initialize PrimeTween before '" + nameof(RuntimeInitializeLoadType) + "." + nameof(RuntimeInitializeLoadType.BeforeSceneLoad) + "'.";
+                            throw new Exception(error);
+                        }
+                    } /*else if (_instance == null) { // todo this throws if PrimeTween API is called from OnDestroy(). See the DestructionOrderTest scene. How to detect manual PrimeTweenManager destruction?
+                        throw new Exception(nameof(PrimeTweenManager) + " was manually destroyed after creation, which is not allowed. Please check you're not destroying all objects manually.");
+                    }*/
+                    return _instance;
+                }
+                private set => _instance = value;
+            }
+        #else
+            internal static PrimeTweenManager Instance;
+        #endif
+
+        internal static bool HasInstance {
+            get {
+                #if UNITY_EDITOR || SAFETY_CHECKS
+                    return !ReferenceEquals(null, _instance);
+                #else
+                    return Instance != null;
+                #endif
+            }
+        }
+
         #if UNITY_EDITOR
-        static bool isHotReload = true;
+            static bool isHotReload = true;
         #endif
         internal static int customInitialCapacity = -1;
 
@@ -58,12 +90,30 @@ namespace PrimeTween {
 
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
         static void beforeSceneLoad() {
+            if (!HasInstance) {
+                CreateInstanceAndDontDestroy();
+            }
+        }
+
+        internal static void CreateInstanceAndDontDestroy() {
+            CreateInstance();
+            DontDestroyOnLoad(Instance.gameObject);
+        }
+
+        static void CreateInstance() {
             #if UNITY_EDITOR
             isHotReload = false;
             #endif
-            Assert.IsNull(Instance);
-            var go = new GameObject(nameof(PrimeTweenManager));
-            DontDestroyOnLoad(go);
+            GameObject go;
+            try {
+                go = new GameObject(nameof(PrimeTweenManager));
+            } catch (UnityException e) {
+                if (e.Message.Contains("is not allowed to be called from a MonoBehaviour constructor")) {
+                    const string message = "this PrimeTween's API is not allowed to be called from a MonoBehaviour constructor (or instance field initializer).";
+                    throw new Exception(message);
+                }
+                throw;
+            }
             var instance = go.AddComponent<PrimeTweenManager>();
             const int defaultInitialCapacity = 200;
             instance.init(customInitialCapacity != -1 ? customInitialCapacity : defaultInitialCapacity);
@@ -83,32 +133,63 @@ namespace PrimeTween {
         }
 
         const string manualInstanceCreationIsNotAllowedMessage = "Please don't create the " + nameof(PrimeTweenManager) + " instance manually.";
-        void Awake() => Assert.IsNull(Instance, manualInstanceCreationIsNotAllowedMessage);
+        void Awake() => Assert.IsFalse(HasInstance, manualInstanceCreationIsNotAllowedMessage);
 
         #if UNITY_EDITOR
         [InitializeOnLoadMethod]
         static void iniOnLoad() {
+            float curTime = (float)EditorApplication.timeSinceStartup;
+            EditorApplication.update += () => {
+                if (Application.isPlaying) {
+                    return;
+                }
+                float newTime = (float)EditorApplication.timeSinceStartup;
+                float unscaledDeltaTime = newTime - curTime;
+                if (unscaledDeltaTime < 1f / 120f) {
+                    return;
+                }
+                if (unscaledDeltaTime > 1f / 10f) {
+                    // Unity Editor doesn't trigger EditorApplication.update when a context menu is open, which results in a big time jump. Clamp dt in this case
+                    unscaledDeltaTime = 1f / 120f;
+                }
+                curTime = newTime;
+                if (HasInstance && Instance.tweensCount > 0) {
+                    float deltaTime = unscaledDeltaTime * Time.timeScale;
+                    Instance.UpdateTweens(_UpdateType.Update, deltaTime, unscaledDeltaTime);
+                    Instance.UpdateTweens(_UpdateType.LateUpdate, deltaTime, unscaledDeltaTime);
+                    Instance.UpdateTweens(_UpdateType.FixedUpdate, deltaTime, unscaledDeltaTime);
+                }
+            };
+
             EditorApplication.playModeStateChanged += state => {
-                if (state == PlayModeStateChange.EnteredEditMode) {
-                    Instance = null;
-                    customInitialCapacity = -1;
+                switch (state) {
+                    case PlayModeStateChange.EnteredEditMode:
+                        Instance = null;
+                        customInitialCapacity = -1;
+                        break;
+                    case PlayModeStateChange.ExitingEditMode:
+                        if (HasInstance) {
+                            DestroyImmediate(Instance.gameObject);
+                            Instance = null;
+                        }
+                        break;
                 }
             };
             if (!isHotReload) {
                 return;
             }
-            if (!Application.isPlaying) {
+            if (HasInstance) {
+                return;
+            }
+            var instances = Resources.FindObjectsOfTypeAll<PrimeTweenManager>();
+            Assert.IsTrue(instances.Length <= 1, instances.Length);
+            if (instances.Length == 0) {
+                return;
+            }
+            var foundInScene = instances[0];
+            if (foundInScene == null) {
                 return;
             }
-            Assert.IsNull(Instance);
-            var foundInScene =
-                #if UNITY_2023_1_OR_NEWER
-                FindAnyObjectByType
-                #else
-                FindObjectOfType
-                #endif
-                <PrimeTweenManager>();
-            Assert.IsNotNull(foundInScene);
             #if PRIME_TWEEN_INSPECTOR_DEBUGGING
             Debug.LogError("PRIME_TWEEN_INSPECTOR_DEBUGGING doesn't work with 'Recompile And Continue Playing' because Tween.id is serializable but Tween.tween is not.");
             return;
@@ -118,20 +199,16 @@ namespace PrimeTween {
                 Debug.Log($"All tweens ({count}) were stopped because of 'Recompile And Continue Playing'.");
             }
             foundInScene.init(foundInScene.currentPoolCapacity);
+            foundInScene.updateDepth = 0;
             Instance = foundInScene;
         }
 
         void Reset() {
             Assert.IsFalse(Application.isPlaying);
-            Debug.LogError(manualInstanceCreationIsNotAllowedMessage);
-            DestroyImmediate(this);
         }
         #endif
 
         void Start() {
-            #if SAFETY_CHECKS
-            // Selection.activeGameObject = gameObject;
-            #endif
             Assert.AreEqual(Instance, this, manualInstanceCreationIsNotAllowedMessage);
         }
 
@@ -296,11 +373,6 @@ namespace PrimeTween {
 
         /// Returns null if target is a destroyed UnityEngine.Object
         internal static Tween? delayWithoutDurationCheck([CanBeNull] object target, float duration, bool useUnscaledTime) {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return null;
-            }
-            #endif
             var tween = fetchTween();
             var settings = new TweenSettings {
                 duration = duration,
@@ -315,11 +387,6 @@ namespace PrimeTween {
 
         [NotNull]
         internal static ReusableTween fetchTween() {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return new ReusableTween();
-            }
-            #endif
             return Instance.fetchTween_internal();
         }
 
@@ -350,22 +417,12 @@ namespace PrimeTween {
         }
 
         internal static void checkDuration<T>([CanBeNull] T target, float duration) where T : class {
-            #if UNITY_EDITOR
-            if (Constants.noInstance) {
-                return;
-            }
-            #endif
             if (Instance.warnZeroDuration && duration <= 0) {
                 Debug.LogWarning($"Tween duration ({duration}) <= 0. {Constants.buildWarningCanBeDisabledMessage(nameof(warnZeroDuration))}", target as UnityEngine.Object);
             }
         }
 
         internal static Tween addTween([NotNull] ReusableTween tween) {
-            #if UNITY_EDITOR
-            if (Constants.noInstance) {
-                return default;
-            }
-            #endif
             return Instance.addTween_internal(tween);
         }
 
@@ -426,11 +483,6 @@ namespace PrimeTween {
         }
 
         internal static int processAll([CanBeNull] object onTarget, [NotNull] Predicate<ReusableTween> predicate, bool allowToProcessTweensInsideSequence) {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return default;
-            }
-            #endif
             return Instance.processAll_internal(onTarget, predicate, allowToProcessTweensInsideSequence);
         }
 

package/Runtime/Internal/ReusableTween.cs

@@ -2,6 +2,7 @@
 #define SAFETY_CHECKS
 #endif
 using System;
+using System.Runtime.CompilerServices;
 using JetBrains.Annotations;
 using UnityEngine;
 using Debug = UnityEngine.Debug;
@@ -31,7 +32,14 @@ namespace PrimeTween {
         internal ref ValueContainer startValue => ref startEndValue.startValue;
         internal ref ValueContainer endValue => ref startEndValue.endValue;
         internal ValueContainer diff;
-        internal bool isAdditive;
+        internal bool isAdditive {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.Additive);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.Additive, value);
+        }
+        internal bool resetBeforeComplete {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.ResetBeforeComplete);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.ResetBeforeComplete, value);
+        }
         internal ValueContainer prevVal;
         [SerializeField] internal TweenSettings settings;
         [SerializeField] int cyclesDone;
@@ -62,10 +70,24 @@ namespace PrimeTween {
         bool stoppedEmergently;
         internal readonly TweenCoroutineEnumerator coroutineEnumerator = new TweenCoroutineEnumerator();
         internal float timeScale = 1f;
-        bool warnIgnoredOnCompleteIfTargetDestroyed = true;
+        bool warnIgnoredOnCompleteIfTargetDestroyed {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.WarnIgnoredOnCompleteIfTargetDestroyed);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.WarnIgnoredOnCompleteIfTargetDestroyed, value);
+        }
         internal ShakeData shakeData;
+        internal bool shakeSign {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.ShakeSign);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.ShakeSign, value);
+        }
+        internal bool isPunch {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.ShakePunch);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.ShakePunch, value);
+        }
         State state;
-        bool warnEndValueEqualsCurrent;
+        bool warnEndValueEqualsCurrent {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => GetFlag(Flags.WarnEndValueEqualsCurrent);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)] set => SetFlag(Flags.WarnEndValueEqualsCurrent, value);
+        }
 
         internal bool updateAndCheckIfRunning(float dt) {
             if (!_isAlive) {
@@ -181,6 +203,16 @@ namespace PrimeTween {
                 }
                 Assert.IsTrue(newCyclesDone == cyclesDone, id);
                 if (isDone(cyclesDiff)) {
+                    if (resetBeforeComplete && isMainSequenceRoot()) {
+                        // reset Sequence
+                        foreach (var t in getSequenceSelfChildren(false)) {
+                            t.tween.updateSequenceChild(0f, true);
+                            if (isEarlyExitAfterChildUpdate()) {
+                                goto EarlyExit;
+                            }
+                        }
+                        EarlyExit:;
+                    }
                     if (isMainSequenceRoot() && !_isPaused) {
                         sequence.releaseTweens();
                     }
@@ -363,11 +395,14 @@ namespace PrimeTween {
             timeScale = 1f;
             warnIgnoredOnCompleteIfTargetDestroyed = true;
             clearOnUpdate();
+            resetBeforeComplete = false;
         }
 
         /// <param name="warnIfTargetDestroyed">https://github.com/KyryloKuzyk/PrimeTween/discussions/4</param>
-        internal void OnComplete([NotNull] Action _onComplete, bool warnIfTargetDestroyed) {
-            Assert.IsNotNull(_onComplete);
+        internal void OnComplete([CanBeNull] Action _onComplete, bool warnIfTargetDestroyed) {
+            if (_onComplete == null) {
+                return;
+            }
             validateOnCompleteAssignment();
             warnIgnoredOnCompleteIfTargetDestroyed = warnIfTargetDestroyed;
             onCompleteCallback = _onComplete;
@@ -382,12 +417,14 @@ namespace PrimeTween {
             };
         }
 
-        internal void OnComplete<T>([CanBeNull] T _target, [NotNull] Action<T> _onComplete, bool warnIfTargetDestroyed) where T : class {
+        internal void OnComplete<T>([CanBeNull] T _target, [CanBeNull] Action<T> _onComplete, bool warnIfTargetDestroyed) where T : class {
             if (_target == null || isDestroyedUnityObject(_target)) {
                 Debug.LogError($"{nameof(_target)} is null or has been destroyed. {Constants.onCompleteCallbackIgnored}");
                 return;
             }
-            Assert.IsNotNull(_onComplete);
+            if (_onComplete == null) {
+                return;
+            }
             validateOnCompleteAssignment();
             warnIgnoredOnCompleteIfTargetDestroyed = warnIfTargetDestroyed;
             onCompleteTarget = _target;
@@ -432,11 +469,6 @@ namespace PrimeTween {
             tweenType = _tweenType;
             var propertyType = propType;
             Assert.AreNotEqual(PropType.None, propertyType);
-            #if UNITY_EDITOR
-            if (Constants.noInstance) {
-                return;
-            }
-            #endif
             if (_settings.ease == Ease.Default) {
                 _settings.ease = PrimeTweenManager.Instance.defaultEase;
             } else if (_settings.ease == Ease.Custom && _settings.parametricEase == ParametricEase.None) {
@@ -508,6 +540,10 @@ namespace PrimeTween {
             Assert.IsFalse(startFromCurrent);
             Assert.IsTrue(timeScale < 0 || cyclesDone == settings.cycles);
             Assert.IsTrue(timeScale >= 0 || cyclesDone == iniCyclesDone);
+            if (resetBeforeComplete && !sequence.IsCreated) {
+                // reset Tween
+                setElapsedTimeTotal(0f, out _);
+            }
             onComplete?.Invoke(this);
         }
 
@@ -849,5 +885,24 @@ namespace PrimeTween {
             Assert.IsTrue(result >= 0);
             return result;
         }
+
+        [Flags]
+        private enum Flags : byte {
+            Additive = 1 << 0,
+            ShakeSign = 1 << 1,
+            ShakePunch = 1 << 2,
+            WarnEndValueEqualsCurrent = 1 << 3,
+            WarnIgnoredOnCompleteIfTargetDestroyed = 1 << 4,
+            ResetBeforeComplete = 1 << 5
+        }
+        [SerializeField] Flags flags = Flags.WarnIgnoredOnCompleteIfTargetDestroyed; // todo how to show this in the Inspector?
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] bool GetFlag(Flags flag) => (flags & flag) != 0;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] void SetFlag(Flags flag, bool value) {
+            if (value) {
+                flags |= flag;
+            } else {
+                flags &= ~flag;
+            }
+        }
     }
 }

package/Runtime/Internal/StackTraces.cs

@@ -42,7 +42,10 @@ namespace PrimeTween {
                 }
             }
             int hash = ComputeHash(buf, len);
-            Assert.AreEqual(id, idToHash.Count);
+            if (id != idToHash.Count) {
+                Debug.LogError("PRIME_TWEEN_SAFETY_CHECKS doesn't support script hot reloading (Recompile And Continue Playing). Please remove the PRIME_TWEEN_SAFETY_CHECKS define."); // todo fix?
+                return;
+            }
             idToHash.Add(hash);
             if (hashToTraces.TryGetValue(hash, out var traces)) {
                 if (!Contains(traces, buf, len)) {

package/Runtime/Internal/TweenGenerated.cs

@@ -135,6 +135,7 @@ namespace PrimeTween {
         VisualElementTopLeft,
         VisualElementColor,
         VisualElementBackgroundColor,
+        VisualElementOpacity,
         TextMaxVisibleCharacters,
         TextFontSize,
     }
@@ -1734,6 +1735,24 @@ namespace PrimeTween {
             }, t => (t.target as UnityEngine.UIElements.VisualElement).style.color.value.ToContainer(), TweenType.VisualElementColor);
         }
 
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Color(target, new TweenSettings<UnityEngine.Color>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Color(target, new TweenSettings<UnityEngine.Color>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color startValue, UnityEngine.Color endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Color(target, new TweenSettings<UnityEngine.Color>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color startValue, UnityEngine.Color endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Color(target, new TweenSettings<UnityEngine.Color>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color endValue, TweenSettings settings) => Color(target, new TweenSettings<UnityEngine.Color>(endValue, settings));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color startValue, UnityEngine.Color endValue, TweenSettings settings) => Color(target, new TweenSettings<UnityEngine.Color>(startValue, endValue, settings));
+        public static Tween Color([NotNull] UnityEngine.UIElements.VisualElement target, TweenSettings<UnityEngine.Color> settings) {
+            return animate(target, ref settings, _tween => {
+                var _target = _tween.target as UnityEngine.UIElements.VisualElement;
+                var val = _tween.ColorVal;
+                _target.style.color = val;
+            }, t => (t.target as UnityEngine.UIElements.VisualElement).style.color.value.ToContainer(), TweenType.VisualElementColor);
+        }
+
         public static Tween VisualElementBackgroundColor([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
             => VisualElementBackgroundColor(target, new TweenSettings<UnityEngine.Color>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
         public static Tween VisualElementBackgroundColor([NotNull] UnityEngine.UIElements.VisualElement target, UnityEngine.Color endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
@@ -1752,6 +1771,42 @@ namespace PrimeTween {
             }, t => (t.target as UnityEngine.UIElements.VisualElement).style.backgroundColor.value.ToContainer(), TweenType.VisualElementBackgroundColor);
         }
 
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => VisualElementOpacity(target, new TweenSettings<float>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => VisualElementOpacity(target, new TweenSettings<float>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => VisualElementOpacity(target, new TweenSettings<float>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => VisualElementOpacity(target, new TweenSettings<float>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, TweenSettings settings) => VisualElementOpacity(target, new TweenSettings<float>(endValue, settings));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, TweenSettings settings) => VisualElementOpacity(target, new TweenSettings<float>(startValue, endValue, settings));
+        public static Tween VisualElementOpacity([NotNull] UnityEngine.UIElements.VisualElement target, TweenSettings<float> settings) {
+            return animate(target, ref settings, _tween => {
+                var _target = _tween.target as UnityEngine.UIElements.VisualElement;
+                var val = _tween.FloatVal;
+                _target.style.opacity = val;
+            }, t => (t.target as UnityEngine.UIElements.VisualElement).style.opacity.value.ToContainer(), TweenType.VisualElementOpacity);
+        }
+
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Alpha(target, new TweenSettings<float>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Alpha(target, new TweenSettings<float>(endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Alpha(target, new TweenSettings<float>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, float duration, Easing ease, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 
+            => Alpha(target, new TweenSettings<float>(startValue, endValue, new TweenSettings(duration, ease, cycles, cycleMode, startDelay, endDelay, useUnscaledTime)));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single endValue, TweenSettings settings) => Alpha(target, new TweenSettings<float>(endValue, settings));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, Single startValue, Single endValue, TweenSettings settings) => Alpha(target, new TweenSettings<float>(startValue, endValue, settings));
+        public static Tween Alpha([NotNull] UnityEngine.UIElements.VisualElement target, TweenSettings<float> settings) {
+            return animate(target, ref settings, _tween => {
+                var _target = _tween.target as UnityEngine.UIElements.VisualElement;
+                var val = _tween.FloatVal;
+                _target.style.opacity = val;
+            }, t => (t.target as UnityEngine.UIElements.VisualElement).style.opacity.value.ToContainer(), TweenType.VisualElementOpacity);
+        }
+
         #endif
         #if TEXT_MESH_PRO_INSTALLED
         public static Tween TextMaxVisibleCharacters([NotNull] TMPro.TMP_Text target, int endValue, float duration, Ease ease = Ease.Default, int cycles = 1, CycleMode cycleMode = CycleMode.Restart, float startDelay = 0, float endDelay = 0, bool useUnscaledTime = false) 

package/Runtime/Internal/TweenMethods.cs

@@ -10,11 +10,6 @@ namespace PrimeTween {
         /// <summary>Returns the number of alive tweens.</summary>
         /// <param name="onTarget">If specified, returns the number of running tweens on the target. Please note: if target is specified, this method call has O(n) complexity where n is the total number of running tweens.</param>
         public static int GetTweensCount([CanBeNull] object onTarget = null) {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return default;
-            }
-            #endif
             var manager = PrimeTweenManager.Instance;
             if (onTarget == null && manager.updateDepth == 0) {
                 int result = manager.tweensCount;

package/Runtime/Internal/Utils.cs

@@ -195,6 +195,8 @@ internal static class Utils {
                 return (PropType.Color, typeof(UnityEngine.UIElements.VisualElement));
             case TweenType.VisualElementBackgroundColor:
                 return (PropType.Color, typeof(UnityEngine.UIElements.VisualElement));
+            case TweenType.VisualElementOpacity:
+                return (PropType.Float, typeof(UnityEngine.UIElements.VisualElement));
             #endif
             #if TEXT_MESH_PRO_INSTALLED
             case TweenType.TextMaxVisibleCharacters:

package/Runtime/PrimeTweenConfig.cs

@@ -1,3 +1,4 @@
+using System;
 using JetBrains.Annotations;
 using UnityEngine;
 
@@ -5,14 +6,7 @@ namespace PrimeTween {
     /// Global PrimeTween configuration.
     [PublicAPI]
     public static partial class PrimeTweenConfig {
-        internal static PrimeTweenManager Instance {
-            get {
-                #if UNITY_EDITOR
-                Assert.IsFalse(Constants.noInstance, Constants.editModeWarning);
-                #endif
-                return PrimeTweenManager.Instance;
-            }
-        }
+        internal static PrimeTweenManager Instance => PrimeTweenManager.Instance;
 
         /// <summary>
         /// If <see cref="PrimeTweenManager"/> instance is already created, <see cref="SetTweensCapacity"/> will allocate garbage,
@@ -30,11 +24,10 @@ namespace PrimeTween {
         /// </example>
         public static void SetTweensCapacity(int capacity) {
             Assert.IsTrue(capacity >= 0);
-            var instance = PrimeTweenManager.Instance; // should use PrimeTweenManager.Instance because Instance property has a built-in null check 
-            if (instance == null) {
-                PrimeTweenManager.customInitialCapacity = capacity;
+            if (PrimeTweenManager.HasInstance) {
+                PrimeTweenManager.Instance.SetTweensCapacity(capacity);
             } else {
-                instance.SetTweensCapacity(capacity);
+                PrimeTweenManager.customInitialCapacity = capacity;
             }
         }
 
@@ -102,5 +95,19 @@ namespace PrimeTween {
             Instance.enabled = false;
             Instance.ApplyStartValues(updateType.enumValue);
         }
+
+        #if PRIME_TWEEN_EXPERIMENTAL
+        public
+        #else
+        internal
+        #endif
+        static void ManualInitialize() {
+            if (!PrimeTweenManager.HasInstance) {
+                PrimeTweenManager.CreateInstanceAndDontDestroy();
+            } else {
+                const string error = "'" + nameof(PrimeTweenManager) + "' is already created. Use this method only to create '" + nameof(PrimeTweenManager) + "' before '" + nameof(RuntimeInitializeLoadType) + "." + nameof(RuntimeInitializeLoadType.BeforeSceneLoad) + "'.";
+                Debug.LogError(error);
+            }
+        }
     }
 }

package/Runtime/Sequence.cs

@@ -101,11 +101,6 @@ namespace PrimeTween {
         }
 
         public static Sequence Create(int cycles = 1, CycleMode cycleMode = CycleMode.Restart, Ease sequenceEase = Ease.Linear, bool useUnscaledTime = false, UpdateType updateType = default) {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return default;
-            }
-            #endif
             var tween = PrimeTweenManager.fetchTween();
             if (cycleMode == CycleMode.Incremental) {
                 Debug.LogError($"Sequence doesn't support CycleMode.Incremental. Parameter {nameof(sequenceEase)} is applied to the sequence's 'timeline', and incrementing the 'timeline' doesn't make sense. For the same reason, {nameof(sequenceEase)} is clamped to [0:1] range.");
@@ -127,11 +122,6 @@ namespace PrimeTween {
         }
 
         public static Sequence Create(Tween firstTween) {
-            #if UNITY_EDITOR
-            if (Constants.warnNoInstance) {
-                return default;
-            }
-            #endif
             return Create().Group(firstTween);
         }
 
@@ -294,22 +284,22 @@ namespace PrimeTween {
             }
             var rootTween = root.tween;
             if (tween._isPaused && tween._isPaused != rootTween._isPaused) {
-                warnIgnoredChildrenSetting(nameof(isPaused));
+                warnIgnoredChildrenSetting(nameof(isPaused), rootTween._isPaused, tween._isPaused);
             }
             if (tween.timeScale != 1f && tween.timeScale != rootTween.timeScale) {
-                warnIgnoredChildrenSetting(nameof(timeScale));
+                warnIgnoredChildrenSetting(nameof(timeScale), rootTween.timeScale, tween.timeScale);
             }
             if (tween.settings.useUnscaledTime && tween.settings.useUnscaledTime != rootTween.settings.useUnscaledTime) {
-                warnIgnoredChildrenSetting(nameof(TweenSettings.useUnscaledTime));
+                warnIgnoredChildrenSetting(nameof(TweenSettings.useUnscaledTime), rootTween.settings.useUnscaledTime, tween.settings.useUnscaledTime);
             }
-            if (tween.settings._updateType != _UpdateType.Default && tween.settings._updateType != rootTween.settings._updateType) {
-                warnIgnoredChildrenSetting(nameof(TweenSettings.updateType));
+            if (tween.settings._updateType != PrimeTweenManager.Instance.defaultUpdateType && tween.settings._updateType != rootTween.settings._updateType) {
+                warnIgnoredChildrenSetting(nameof(TweenSettings.updateType), rootTween.settings._updateType, tween.settings._updateType);
             }
-            void warnIgnoredChildrenSetting(string settingName) {
-                Debug.LogError($"'{settingName}' was ignored after adding child animation to the Sequence. Parent Sequence controls '{settingName}' of all its children animations.\n" +
-                               "To prevent this error:\n" +
+            void warnIgnoredChildrenSetting(string settingName, object sequenceSetting, object childSetting) {
+                Debug.LogError($"'{settingName}' was ignored after adding child animation to the Sequence (Sequence has '{sequenceSetting}', but the child had '{childSetting}').\n" +
+                               $"Parent Sequence controls '{settingName}' of all its children animations. To prevent this error:\n" +
                                $"- Use the default value of '{settingName}' in child animation.\n" +
-                               $"- OR use the same '{settingName}' in child animation.\n\n");
+                               $"- OR use the same '{settingName}' in child animation.\n");
             }
             return true;
         }
@@ -613,5 +603,13 @@ namespace PrimeTween {
 
         public override int GetHashCode() => root.GetHashCode();
         public bool Equals(Sequence other) => root.Equals(other.root);
+
+        #if PRIME_TWEEN_EXPERIMENTAL
+        public
+        #endif
+        Sequence ResetBeforeComplete() {
+            root.ResetBeforeComplete();
+            return this;
+        }
     }
 }

package/Runtime/Shake.cs

@@ -108,7 +108,7 @@ namespace PrimeTween {
 
         static void prepareShakeData(ShakeSettings settings, [NotNull] ReusableTween tween) {
             tween.endValue.Reset(); // not used
-            tween.shakeData.Setup(settings);
+            tween.shakeData.Setup(settings, tween);
         }
 
         static Vector3 getShakeVal([NotNull] ReusableTween tween) {
@@ -145,13 +145,11 @@ namespace PrimeTween {
     #endif
     internal struct ShakeData {
         float t;
-        bool sign;
         Vector3 from, to;
         float symmetryFactor;
         int falloffEaseInt;
         AnimationCurve customStrengthOverTime;
         Ease easeBetweenShakes;
-        bool isPunch;
         const int disabledFalloff = -42;
         internal bool isAlive => frequency != 0f;
         internal Vector3 strengthPerAxis { get; private set; }
@@ -159,8 +157,8 @@ namespace PrimeTween {
         float prevInterpolationFactor;
         int prevCyclesDone;
 
-        internal void Setup(ShakeSettings settings) {
-            isPunch = settings.isPunch;
+        internal void Setup(ShakeSettings settings, ReusableTween tween) {
+            tween.isPunch = settings.isPunch;
             symmetryFactor = Mathf.Clamp01(1 - settings.asymmetry);
             {
                 var _strength = settings.strength;
@@ -207,14 +205,14 @@ namespace PrimeTween {
                 }
                 easeBetweenShakes = _easeBetweenShakes;
             }
-            onCycleComplete();
+            onCycleComplete(tween);
         }
 
-        internal void onCycleComplete() {
+        internal void onCycleComplete(ReusableTween tween) {
             Assert.IsTrue(isAlive);
             resetAfterCycle();
-            sign = isPunch || Random.value < 0.5f;
-            to = generateShakePoint();
+            tween.shakeSign = tween.isPunch || Random.value < 0.5f;
+            to = generateShakePoint(tween);
         }
 
         static int getMainAxisIndex(Vector3 strengthByAxis) {
@@ -238,7 +236,7 @@ namespace PrimeTween {
             int cyclesDiff = tween.getCyclesDone() - prevCyclesDone;
             prevCyclesDone = tween.getCyclesDone();
             if (interpolationFactor == 0f || (cyclesDiff > 0 && tween.getCyclesDone() != tween.settings.cycles)) {
-                onCycleComplete();
+                onCycleComplete(tween);
                 prevInterpolationFactor = interpolationFactor;
             }
 
@@ -255,15 +253,15 @@ namespace PrimeTween {
             }
             t += frequency * dt * frequencyFactor * getIniVelFactor();
             if (t < 0f || t >= 1f) {
-                sign = !sign;
+                tween.shakeSign = !tween.shakeSign;
                 if (t < 0f) {
                     t = 1f;
                     to = from;
-                    from = generateShakePoint();
+                    from = generateShakePoint(tween);
                 } else {
                     t = 0f;
                     from = to;
-                    to = generateShakePoint();
+                    to = generateShakePoint(tween);
                 }
             }
 
@@ -274,13 +272,13 @@ namespace PrimeTween {
             return result;
         }
 
-        Vector3 generateShakePoint() {
+        Vector3 generateShakePoint(ReusableTween tween) {
             var mainAxisIndex = getMainAxisIndex(strengthPerAxis);
             Vector3 result = default;
-            float signFloat = sign ? 1f : -1f;
+            float signFloat = tween.shakeSign ? 1f : -1f;
             for (int i = 0; i < 3; i++) {
                 var strength = strengthPerAxis[i];
-                if (isPunch) {
+                if (tween.isPunch) {
                     result[i] = clampBySymmetryFactor(strength * signFloat, strength, symmetryFactor);
                 } else {
                     result[i] = i == mainAxisIndex ? calcMainAxisEndVal(signFloat, strength, symmetryFactor) : calcNonMainAxisEndVal(strength, symmetryFactor);

package/Runtime/Tween.cs

@@ -276,7 +276,7 @@ namespace PrimeTween {
 
         /// <summary>Adds completion callback. Please consider using <see cref="OnComplete{T}"/> to prevent a possible capture of variable into a closure.</summary>
         /// <param name="warnIfTargetDestroyed">Set to 'false' to disable the error about target's destruction. Please note that the the <see cref="onComplete"/> callback will be silently ignored in the case of target's destruction. More info: https://github.com/KyryloKuzyk/PrimeTween/discussions/4</param>
-        public Tween OnComplete(Action onComplete, bool warnIfTargetDestroyed = true) {
+        public Tween OnComplete([CanBeNull] Action onComplete, bool warnIfTargetDestroyed = true) {
             if (validateIsAlive()) {
                 tween.OnComplete(onComplete, warnIfTargetDestroyed);
             }
@@ -291,7 +291,7 @@ namespace PrimeTween {
         /// Tween.PositionX(transform, endValue: 1.5f, duration: 1f)
         ///     .OnComplete(transform, _transform =&gt; Destroy(_transform.gameObject));
         /// </code></example>
-        public Tween OnComplete<T>([NotNull] T target, Action<T> onComplete, bool warnIfTargetDestroyed = true) where T : class {
+        public Tween OnComplete<T>([NotNull] T target, [CanBeNull] Action<T> onComplete, bool warnIfTargetDestroyed = true) where T : class {
             if (validateIsAlive()) {
                 tween.OnComplete(target, onComplete, warnIfTargetDestroyed);
             }
@@ -336,5 +336,17 @@ namespace PrimeTween {
         public override int GetHashCode() => id.GetHashCode();
         /// https://www.jacksondunstan.com/articles/5148
         public bool Equals(Tween other) => isAlive && other.isAlive && id == other.id;
+
+        #if PRIME_TWEEN_EXPERIMENTAL
+        public
+        #else
+        internal
+        #endif
+        Tween ResetBeforeComplete() {
+            if (validateIsAlive()) {
+                tween.resetBeforeComplete = true;
+            }
+            return this;
+        }
     }
 }

package/Tests/DestructionOrderTest.cs

@@ -4,7 +4,7 @@ using UnityEngine;
 
 public class DestructionOrderTest : MonoBehaviour {
     void OnDestroy() {
-        print($"PrimeTweenManager.Instance == null: {PrimeTweenManager.Instance == null}");
+        print($"PrimeTweenManager.HasInstance: {PrimeTweenManager.HasInstance}, PrimeTweenManager._instance != null:{PrimeTweenManager._instance != null}");
         Tween.StopAll(transform);
         Tween.CompleteAll(transform);
         Tween.Custom(0, 1, 1, delegate {});

package/Tests/EditModeTest.cs

@@ -2,23 +2,73 @@
 // ReSharper disable NotAccessedField.Local
 // ReSharper disable UnusedMember.Local
 // ReSharper disable PartialTypeWithSinglePart
+using System;
 using PrimeTween;
 using UnityEngine;
 using Assert = NUnit.Framework.Assert;
-using AssertionException = UnityEngine.Assertions.AssertionException;
 
 [ExecuteInEditMode]
 public partial class EditModeTest : MonoBehaviour {
-    [SerializeField] TweenSettings _settings = new TweenSettings(1, AnimationCurve.Linear(0, 0, 1, 1));
-    Tween tween = test();
-    Sequence sequence = Sequence.Create();
-    
-    static Tween test() {
-        Assert.IsTrue(Constants.noInstance, "This test is designed only for Edit mode.");
-        PrimeTweenConfig.SetTweensCapacity(10);
-        Assert.Throws<AssertionException>(() => PrimeTweenConfig.warnZeroDuration = false);
+    [SerializeField] TweenSettings _settings = CreateSettings();
+    static TweenSettings CreateSettings() {
+        TweenSettings res = default;
+        if (!PrimeTweenManager.HasInstance) {
+            ExpectConstructorException(() => res = new TweenSettings(1, AnimationCurve.Linear(0, 0, 1, 1)));
+        }
+        return res;
+    }
+
+    Tween tween = TestConstructor();
+
+    static Tween TestConstructor() {
+        if (PrimeTweenManager.HasInstance) {
+            if (PrimeTweenManager.Instance.tweensCount > 0) {
+                ExpectConstructorException(() => Tween.StopAll());
+            }
+            return TestRegular();
+        }
+        ExpectConstructorException(() => Sequence.Create());
+        ExpectConstructorException(() => PrimeTweenConfig.SetTweensCapacity(PrimeTweenManager.Instance.currentPoolCapacity + 1));
+        ExpectConstructorException(() => PrimeTweenConfig.warnZeroDuration = !PrimeTweenConfig.warnZeroDuration);
+        ExpectConstructorException(() => Tween.GlobalTimeScale(1f, 0.1f));
+        ExpectConstructorException(() => Tween.GetTweensCount());
+        ExpectConstructorException(() => {
+            Sequence.Create()
+                .ChainCallback(() => {})
+                .InsertCallback(0f, delegate {})
+                .Group(StartTween())
+                .Chain(StartTween())
+                .Insert(0f, Sequence.Create())
+                .Insert(0, StartTween());
+        });
+        ExpectConstructorException(() => Tween.Delay(new object(), 1f, () => {}));
+        ExpectConstructorException(() => Tween.Delay(new object(), 1f, _ => {}));
+        ExpectConstructorException(() => Tween.Delay(1f, () => { }));
+        ExpectConstructorException(() => Tween.Custom(0, 1, 1, delegate {}));
+        return default;
+    }
+
+    static void ExpectConstructorException(Action action) {
+        try {
+            action();
+            // Assert.Fail(nameof(action) + " should throw when called from constructor."); // calling Unity API is allowed from constructor when Editor is opening for the first time, so this assertion is commented out
+        } catch (Exception e) {
+            string message = e.Message;
+            Assert.IsTrue(message.Contains("is not allowed to be called from a MonoBehaviour constructor"), message);
+        }
+    }
+
+    static void test() {
         Tween.StopAll();
-        Tween.GlobalTimeScale(0.5f, 0.1f);
+        TestRegular();
+    }
+
+    static Tween TestRegular() {
+        PrimeTweenConfig.SetTweensCapacity(PrimeTweenManager.Instance.currentPoolCapacity + 1);
+        Assert.DoesNotThrow(() => PrimeTweenConfig.warnZeroDuration = false);
+        PrimeTweenConfig.warnEndValueEqualsCurrent = false;
+        Tween.GlobalTimeScale(1f, 0.1f);
+        PrimeTweenConfig.warnEndValueEqualsCurrent = true;
         Tween.GetTweensCount();
         Sequence.Create()
             .ChainCallback(() => {})
@@ -27,7 +77,7 @@ public partial class EditModeTest : MonoBehaviour {
             .Chain(StartTween())
             .Insert(0f, Sequence.Create())
             .Insert(0, StartTween());
-        Tween.Delay(new object(), 1f, () => { });
+        Tween.Delay(new object(), 1f, () => {});
         Tween.Delay(new object(), 1f, _ => {});
         Tween.Delay(1f, () => { });
         return Tween.Custom(0, 1, 1, delegate {});
@@ -45,8 +95,8 @@ public partial class EditModeTest : MonoBehaviour {
 
 /*[UnityEditor.InitializeOnLoad]
 public partial class EditModeTest {
-    static EditModeTest() => test();
-    EditModeTest() => test();
+    static EditModeTest() => TestConstructor();
+    EditModeTest() => TestConstructor();
 
     [RuntimeInitializeOnLoadMethod]
     static void runtimeInitOnLoad() => test();

package/Tests/Sequence.cs

@@ -351,6 +351,10 @@ public partial class Tests {
         seq.Chain(createSequenceWithNonDefaultSettings());
         LogAssert.NoUnexpectedReceived();
 
+        Sequence.Create(updateType: UpdateType.FixedUpdate)
+            .Group(Tween.PositionY(transform, new(5, 0.1f)))
+            .ChainCallback(() => {});
+
         return;
 
         static void expectErrors() {

package/changelog.md

@@ -1,3 +1,20 @@
+## [1.3.2] - 2025-05-18
+### Fixed
+- Fixed: the 'updateType was ignored' error appears if a tween with default 'updateType' is added to a Sequence. https://github.com/KyryloKuzyk/PrimeTween/issues/171
+
+## [1.3.1] - 2025-04-27
+### Added
+- Add Edit mode support, so animations can be played in Editor without entering the Play mode. https://github.com/KyryloKuzyk/PrimeTween/discussions/62
+- PrimeTween can now be installed via Unity Package Manager.
+- Demo project: add 'Play Animation' button to Inspector to preview animations in Edit mode without entering Play mode.
+- Add the experimental `ResetAfterComplete()` method to reset animations to the initial value before completion. https://github.com/KyryloKuzyk/PrimeTween/discussions/153
+- Add the experimental `PrimeTweenConfig.ManualInitialize()` to initialize PrimeTween before `RuntimeInitializeLoadType.BeforeSceneLoad`. https://github.com/KyryloKuzyk/PrimeTween/issues/150
+- Add `Tween.VisualElementOpacity()` method to animate the `VisualElement.style.opacity` property. Also, extend `Tween.Color/Alpha` methods to also work with VisualElement.
+### Changed
+- Passing `null` to `OnComplete()` is now allowed and no longer results in an error. https://github.com/KyryloKuzyk/PrimeTween/discussions/164
+### Fixed
+- Fixed: PrimeTween doesn't work after scripts are recompiled while playing in Editor when the 'Recompile And Continue Playing' setting is enabled.
+
 ## [1.3.0] - 2025-04-04
 ### Added
 - Add support for updating animations in LateUpdate with the help of the new 'UpdateType updateType' parameter. The available options are Update, LateUpdate, and FixedUpdate. https://github.com/KyryloKuzyk/PrimeTween/issues/138

package/license.md

@@ -1,10 +1,12 @@
-PrimeTween is licensed under the Asset Store EULA:  
-https://unity3d.com/legal/as_terms
+It's **allowed**:
+- Use PrimeTween and modify its source code in **free and commercial** products distributed in binary format (apps and games).
+- Use PrimeTween in derivative (free and commercial) projects (templates, libraries, GitHub projects) that depend on PrimeTween, but only if PrimeTween is installed as an [**NPM package**](https://github.com/KyryloKuzyk/PrimeTween#install-via-unity-package-manager-upm).
 
-In short, it's allowed to use and modify PrimeTween in products distributed in binary format (apps and games).
-But it's not allowed to redistribute it or create derivative libraries based on PrimeTween.
+It's **not allowed**:
+- Distribute PrimeTween's source code and tarball (.tgz) archive inside derivative products. To build templates or libraries that depend on PrimeTween, use the NPM installation method instead.
+- Distribute, resell, or claim PrimeTween's ownership even if modified.
+- Resell PrimeTween by itself or as part of another library or asset pack.
 
-To create other libraries that depend on PrimeTween, please refer to this forum post:  
-https://forum.unity.com/threads/1479609/page-4#post-9587461
+**In short**: you can use PrimeTween in your Unity projects, including commercial ones, but you can’t repackage or resell PrimeTween itself.
 
-Copyright: Kyrylo Kuzyk 2023
+Copyright: Kyrylo Kuzyk 2023

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "com.kyrylokuzyk.primetween",
   "displayName": "PrimeTween",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "unity": "2018.4",
   "author": {
     "name": "Kyrylo Kuzyk"
@@ -32,9 +32,13 @@
     "Animate"
   ],
   "documentationUrl": "https://github.com/KyryloKuzyk/PrimeTween",
+  "changelogUrl": "https://github.com/KyryloKuzyk/PrimeTween/blob/main/changelog.md",
+  "_upm": {
+    "changelog": "### Fixed\n- Fixed: the 'updateType was ignored' error appears if a tween with default 'updateType' is added to a Sequence. https://github.com/KyryloKuzyk/PrimeTween/issues/171"
+  },
   "repository": {
     "url": "git@bitbucket.org:stampedegames/primetween.git",
     "type": "git",
-    "revision": "35bc62132b4f2ee6a369863fd55f2e59a038f028"
+    "revision": "3cecdc457560520e4d1945a66ab3e26029619f2a"
   }
 }

package/{Documentation.md → readme.md}

@@ -11,6 +11,7 @@ PrimeTween is a high-performance, **allocation-free** animation library for Unit
 Table of Contents
 ---
 - [Getting started](#getting-started)
+  * [Installation](#installation)
   * [Animations](#animations)
   * [Shakes](#shakes)
   * [Callbacks](#callbacks)
@@ -29,6 +30,7 @@ Table of Contents
   + [Speed-based animations](#speed-based-animations)
   + [Custom easing](#custom-easing)
   + [LateUpdate/FixedUpdate](#lateupdatefixedupdate)
+  + [Install via Unity Package Manager (UPM)](#install-via-unity-package-manager-upm)
 - [Zero allocations with delegates](#zero-allocations-with-delegates)
 - [Debugging tweens](#debugging-tweens)
 - [Migrating from DOTween to PrimeTween](#migrating-from-dotween-to-primetween)
@@ -42,7 +44,8 @@ Getting started
 ---
 
 ### Installation
-Import PrimeTween from [Asset Store](https://assetstore.unity.com/packages/slug/252960).
+Import PrimeTween from [Asset Store](https://assetstore.unity.com/packages/slug/252960).  
+Optional: install via Unity [Package Manager](#install-via-unity-package-manager-upm) (UPM).
 
 ### Animations
 Without further ado, let's jump straight to the code!
@@ -359,7 +362,7 @@ Available parametric eases:
 ### LateUpdate/FixedUpdate
 Use `updateType` parameter to chose which Unity even function will update the animation. The available options are Update, LateUpdate, and FixedUpdate.  
 ```csharp
-// Use TweenSettings or TweenSettings<T> struct to pass the 'lateUpdate' parameter to static 'Tween.' methods
+// Use TweenSettings or TweenSettings<T> struct to pass the 'updateType' parameter to static 'Tween.' methods
 Tween.PositionX(transform, endValue: 10f, new TweenSettings(duration: 1f, updateType: UpdateType.LateUpdate));
 
 var tweenSettingsFloat = new TweenSettings<float>(endValue: 10f, duration: 1f, updateType: UpdateType.FixedUpdate);
@@ -369,6 +372,33 @@ Tween.PositionX(transform, tweenSettingsFloat);
 Sequence.Create(updateType: UpdateType.FixedUpdate);
 ```
 
+### Install via Unity Package Manager (UPM)
+The Package Manager installation method allows to include PrimeTween in derivative (free and commercial) projects (templates, libraries, GitHub repositories). For more info, see the [license](https://github.com/KyryloKuzyk/PrimeTween?tab=License-1-ov-file).  
+This installation method also helps to clean the project structure.
+- Open 'Edit / Project Settings / Package Manager'.
+- Add a new Scoped Registry with Name: `npm` URL: `https://registry.npmjs.org` Scope(s): `com.kyrylokuzyk`.
+- Go to 'Window / Package Manager / Packages / My Registries'.
+- Install the PrimeTween package.
+  
+Or modify the `Packages/manifest.json' file manually:
+```json
+{
+  "dependencies": {
+    "com.kyrylokuzyk.primetween": "1.3.2",
+    ...
+  },
+  "scopedRegistries": [
+    {
+      "name": "npm",
+      "url": "https://registry.npmjs.org/",
+      "scopes": [
+        "com.kyrylokuzyk"
+      ]
+    }
+  ]
+}
+``` 
+
 Zero allocations with delegates
 ---
 C# delegates is a powerful language feature essential for game development. It gives us the ability to receive callbacks and pass methods to other methods. But when delegates are used in hot code paths carelessly, they can create [performance issues](https://www.jacksondunstan.com/articles/3765).