Tween extensions

README.md

@@ -23,15 +23,15 @@ Includes a SRP shader for blurring the background of UI panels.
 #### Using UnityPackageManager (for Unity 2019.3 or later)
 Open the package manager window (menu: Window > Package Manager)<br/>
 Select "Add package from git URL...", fill in the pop-up with the following link:<br/>
-https://github.com/coryleach/UnityGUI.git#3.0.1<br/>
+https://github.com/coryleach/UnityGUI.git#3.0.2<br/>
 
 #### Using UnityPackageManager (for Unity 2019.1 or later)
 
 Find the manifest.json file in the Packages folder of your project and edit it to look like this:
 ```js
 {
   "dependencies": {
-    "com.gameframe.gui": "https://github.com/coryleach/UnityGUI.git#3.0.1",
+    "com.gameframe.gui": "https://github.com/coryleach/UnityGUI.git#3.0.2",
     ...
   },
 }

Runtime/Tween/TransformTweenExtensions.cs

@@ -0,0 +1,104 @@
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Gameframe.GUI.Tween
+{
+    public static class TransformTweenExtensions
+    {
+        public static async void DoPosX(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            await transform.DoPosXAsync(position, duration, easing).ConfigureAwait(false);
+        }
+
+        public static async void DoPosY(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            await transform.DoPosYAsync(position, duration, easing).ConfigureAwait(false);
+        }
+
+        public static async void DoPosZ(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            await transform.DoPosYAsync(position, duration, easing).ConfigureAwait(false);
+        }
+
+        public static async Task DoPosXAsync(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            var start = transform.position.x;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                var pt = transform.position;
+                pt.x = Mathf.Lerp(start, position, t);
+                transform.position = pt;
+            }, easing);
+        }
+
+        public static async Task DoPosYAsync(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            var start = transform.position.y;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                var pt = transform.position;
+                pt.y = Mathf.Lerp(start, position, t);
+                transform.position = pt;
+            }, easing);
+        }
+
+        public static async Task DoPosZAsync(this Transform transform, float position, float duration, Easing easing = Easing.Linear)
+        {
+            var start = transform.position.z;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                var pt = transform.position;
+                pt.z = Mathf.Lerp(start, position, t);
+                transform.position = pt;
+            }, easing);
+        }
+
+        public static async Task DoMoveAsync(this Transform transform, Vector3 position, float duration, Easing easing = Easing.Linear)
+        {
+            var startPos = transform.position;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                var pt = Vector3.Lerp(startPos, position, t);
+                transform.position = pt;
+            }, easing);
+        }
+
+        public static async void DoMove(this Transform transform, Vector3 position, float duration, Easing easing = Easing.Linear)
+        {
+            await transform.DoMoveAsync(position, duration, easing).ConfigureAwait(false);
+        }
+
+        public static async Task DoLocalMoveAsync(this Transform transform, Vector3 position, float duration, Easing easing = Easing.Linear)
+        {
+            var startPos = transform.position;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                var pt = Vector3.Lerp(startPos, position, t);
+                transform.localPosition = pt;
+            }, easing);
+        }
+
+        public static async void DoLocalMove(this Transform transform, Vector3 position, float duration, Easing easing = Easing.Linear)
+        {
+            await transform.DoLocalMoveAsync(position, duration, easing).ConfigureAwait(false);
+        }
+
+        public static async Task DoPunchPosition(this Transform transform, Vector3 position, float duration, Easing easing = Easing.Linear)
+        {
+            var startPos = transform.position;
+            await TweenExtensions.DoTweenAsync(transform.gameObject.GetInstanceID(), duration, (t) =>
+            {
+                t *= 2;
+                if (t > 1)
+                {
+                    t = 2 - t;
+                }
+
+                var pt = Vector3.Lerp(startPos, position, t);
+                transform.localPosition = pt;
+            }, easing);
+        }
+
+
+    }
+}

Runtime/Tween/TweenExtensions.cs

@@ -49,14 +49,28 @@ public static void DoKillTweens(this Component obj)
         {
             CancelTweensForId(obj.GetInstanceID());
         }
-        
+
         public static async Task DoTweenAsync(int id, float duration, Action<float> action, Easing easeType = Easing.Linear)
         {
             await DoTweenAsync(id, duration, _cancellationTokenSource.Token, action, easeType).ConfigureAwait(false);
         }
 
-        public static async Task DoTweenAsync(int id, float duration, CancellationToken cancellationToken,
-            Action<float> action, Easing easeType = Easing.Linear)
+        public static async Task DoPunchTweenAsync(int id, float duration, Action<float> action, Easing easeType = Easing.Linear)
+        {
+            await DoPunchTweenAsync(id, duration, _cancellationTokenSource.Token, action, easeType).ConfigureAwait(false);
+        }
+
+        public static Task DoTweenAsync(int id, float duration, CancellationToken cancellationToken, Action<float> action, Easing easeType = Easing.Linear)
+        {
+            return DoTweenAsyncWithLerp(InverseLerpFloat, id, duration, cancellationToken, action, easeType);
+        }
+
+        public static Task DoPunchTweenAsync(int id, float duration, CancellationToken cancellationToken, Action<float> action, Easing easeType = Easing.Linear)
+        {
+            return DoTweenAsyncWithLerp(PunchInverseLerpFloat, id, duration, cancellationToken, action, easeType);
+        }
+
+        public static async Task DoTweenAsyncWithLerp(Func<float,float,float,float> lerpMethod, int id, float duration, CancellationToken cancellationToken, Action<float> action, Easing easeType = Easing.Linear)
         {
             var instanceCancellationToken = StartTween(id);
 
@@ -74,20 +88,36 @@ public static async Task DoTweenAsync(int id, float duration, CancellationToken
                 }
 
                 t += Time.deltaTime;
-                action?.Invoke(ease.Invoke(Mathf.InverseLerp(0, duration, t)));
+                action?.Invoke(ease.Invoke(lerpMethod(0, duration, t)));
             }
 
             //Just exit immediately if we've stopped playing in editor
             if (!Application.isPlaying)
             {
                 return;
             }
-            
-            action?.Invoke(ease.Invoke(1));
+
+            action?.Invoke(ease.Invoke(lerpMethod(0, duration, duration)));
 
             CompleteTween(id);
         }
 
+        private static float InverseLerpFloat(float a, float b, float t)
+        {
+            return Mathf.InverseLerp(a, b, t);
+        }
+
+        private static float PunchInverseLerpFloat(float a, float b, float t)
+        {
+            var r =  Mathf.InverseLerp(a, b, t);
+            r *= 2;
+            if (r > 1)
+            {
+                r = 2 - r;
+            }
+            return r;
+        }
+
         private static CancellationToken StartTween(int id)
         {
             var tweenData = GetTweenData(id);
@@ -148,4 +178,4 @@ private class TweenData
             public int count;
         }
     }
-}
+}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "com.gameframe.gui",
   "displayName": "Gameframe.GUI",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "This is a library of GUI helpers for UGUI  \r\nIncludes a panel system that implements a navigation stack.  \r\nIncludes a scene transition system.  \r\nIncludes a SRP shader for blurring the background of UI panels.",
   "keywords": [],
   "author": {