refactor: MilHandleFunction

buger404 · buger404 · commit d5d3ce914e29 · 2024-07-22T17:26:39.000+08:00
diff --git a/README.md b/README.md
@@ -64,11 +64,11 @@ var animation =
                 Text.Milease(nameof(Text.text), "Start!", "Finish!", 1f)
             )
             .Then(
-                Text.Milease((o, p) =>
+                Text.Milease((e) =>
                 {
-                    var text = o as TMP_Text;
-                    text.text = $"Hide after {((1f - p) * 2f):F1}s...";
-                }, null,2f, 0f, EaseFunction.Linear)
+                    var text = e.GetTarget<TMP_Text>();
+                    text.text = $"Hide after {((1f - e.Progress) * 2f):F1}s...";
+                }, null, 2f, 0f, EaseFunction.Linear)
             )
             .Then(
                 Text.gameObject.Milease(HandleFunction.Hide, HandleFunction.AutoActiveReset(Text.gameObject), 0f)
diff --git a/Scripts/Milease/Core/Animation/MilAnimation.cs b/Scripts/Milease/Core/Animation/MilAnimation.cs
@@ -6,7 +6,6 @@
 
 namespace Milease.Core.Animation
 {
-    public delegate void MileaseHandleFunction(object target, float progress);
     public class MilAnimation : ScriptableObject
     {
         public enum BlendingMode
@@ -107,7 +106,7 @@ public static AnimationPart SimplePart(object startValue, object toValue, float
             };
         }
 
-        internal static AnimationPart SimplePart(MileaseHandleFunction handleFunction, MileaseHandleFunction resetFunction, float duration, float delay = 0f,
+        internal static AnimationPart SimplePart(float duration, float delay = 0f,
             EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In, BlendingMode blendingMode = BlendingMode.Default)
         {
             return new AnimationPart()
diff --git a/Scripts/Milease/Core/Animation/MilHandleFunctionArgs.cs b/Scripts/Milease/Core/Animation/MilHandleFunctionArgs.cs
@@ -0,0 +1,18 @@
+﻿using Milease.Core.Animator;
+
+namespace Milease.Core.Animation
+{
+    public struct MilHandleFunctionArgs
+    {
+        internal object target;
+        public float Progress { get; internal set; }
+        public RuntimeAnimationPart Animation { get; internal set; }
+        public MilInstantAnimator Animator { get; internal set; }
+
+        public T GetTarget<T>()
+        {
+            return (T)target;
+        }
+    }
+    public delegate void MileaseHandleFunction(MilHandleFunctionArgs e);
+}
diff --git a/Scripts/Milease/Core/Animation/MilHandleFunctionArgs.cs.meta b/Scripts/Milease/Core/Animation/MilHandleFunctionArgs.cs.meta
diff --git a/Scripts/Milease/Core/RuntimeAnimationPart.cs b/Scripts/Milease/Core/RuntimeAnimationPart.cs
@@ -3,6 +3,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using Milease.Core.Animation;
+using Milease.Core.Animator;
 using Milease.Enums;
 using Milease.Milease.Exception;
 using UnityEngine;
@@ -34,19 +35,21 @@ public enum AnimationResetMode
         public object StartValue, ToValue, OriginalValue;
         public readonly object Target;
         public readonly MilAnimation.AnimationPart Source;
+        public readonly MilInstantAnimator ParentAnimator;
         public bool IsPrepared { get; private set; }
         public string MemberPath { get; private set; }
 
         private float lastProgress = -1f;
 
-        public RuntimeAnimationPart(object target, MilAnimation.AnimationPart animation, MileaseHandleFunction handleFunction, MileaseHandleFunction resetFunction = null)
+        public RuntimeAnimationPart(object target, MilInstantAnimator animator, MilAnimation.AnimationPart animation, MileaseHandleFunction handleFunction, MileaseHandleFunction resetFunction = null)
         {
             HandleFunction = handleFunction;
             Source = animation;
             Target = target;
             Valid = true;
             ResetFunction = resetFunction;
             ValueType = ValueTypeEnum.SelfHandle;
+            ParentAnimator = animator;
             MemberPath = handleFunction.GetHashCode().ToString();
         }
 
@@ -71,7 +74,13 @@ public bool Reset(AnimationResetMode resetMode)
             
             if (ResetFunction != null)
             {
-                ResetFunction(Target, 0f);
+                ResetFunction(new MilHandleFunctionArgs()
+                {
+                    Animation = this,
+                    target = Target,
+                    Progress = 0f,
+                    Animator = ParentAnimator
+                });
                 return true;
             }
             
@@ -118,14 +127,15 @@ public bool Reset(AnimationResetMode resetMode)
         }
         
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public RuntimeAnimationPart(object target, MilAnimation.AnimationPart animation, Type baseType, MemberInfo memberInfo = null)
+        public RuntimeAnimationPart(object target, MilInstantAnimator animator, MilAnimation.AnimationPart animation, Type baseType, MemberInfo memberInfo = null)
         {
             if (target == null)
             {
                 throw new MilTargetNotFoundException();
             }
             
             Source = animation;
+            ParentAnimator = animator;
             
             var curType = baseType;
             if (memberInfo != null)
@@ -259,7 +269,13 @@ public static void SetValue(RuntimeAnimationPart ani, float pro)
             
             if (ani.ValueType == ValueTypeEnum.SelfHandle)
             {
-                ani.HandleFunction(ani.Target, pro);
+                ani.HandleFunction(new MilHandleFunctionArgs()
+                {
+                    Animation = ani,
+                    target = ani.Target,
+                    Progress = pro,
+                    Animator = ani.ParentAnimator
+                });
                 return;
             }
             
diff --git a/Scripts/Milease/Extension/MilInstantAnimatorExtension.cs b/Scripts/Milease/Extension/MilInstantAnimatorExtension.cs
@@ -17,7 +17,7 @@ namespace Milease.Utils
     public static class MilInstantAnimatorExtension
     {
         public static MilInstantAnimator AsMileaseKeyEvent(this Action action, float delay = 0f)
-            => Milease(action, (_, _) => action.Invoke(), null, 0f, delay);
+            => Milease(action, (_) => action.Invoke(), null, 0f, delay);
         
         public static MilInstantAnimator AsMileaseHandleFunction(this MileaseHandleFunction func, float duration, float delay = 0f)
             => Milease(func, func, null, duration, delay);
@@ -32,37 +32,37 @@ public static MilInstantAnimator Milease(this object target, MileaseHandleFuncti
             EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In, 
             MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)
         {
-            var animation = new MilInstantAnimator();
-            var ani = MilAnimation.SimplePart(handleFunction, resetFunction, duration, delay, easeFunction, easeType, blendingMode);
-            animation.Collection.Add(new List<RuntimeAnimationPart>()
+            var animator = new MilInstantAnimator();
+            var ani = MilAnimation.SimplePart(duration, delay, easeFunction, easeType, blendingMode);
+            animator.Collection.Add(new List<RuntimeAnimationPart>()
             {
-                new (target, ani, handleFunction, resetFunction)
+                new (target, animator, ani, handleFunction, resetFunction)
             });
-            return animation;
+            return animator;
         }
         
         public static MilInstantAnimator MileaseTo(this object target, string memberName, object toValue, 
             float duration, float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad, 
             EaseType easeType = EaseType.In)
         {
-            var animation = new MilInstantAnimator();
+            var animator = new MilInstantAnimator();
             var type = target.GetType();
             var members = type.GetMember(memberName);
             if (members.Length == 0)
             {
                 throw new MilMemberNotFoundException(memberName);
             }
             var info = members[0];
-            animation.Collection.Add(new List<RuntimeAnimationPart>()
+            animator.Collection.Add(new List<RuntimeAnimationPart>()
             {
-                new (target, MilAnimation.SimplePartTo(toValue, duration, delay, easeFunction, easeType), info.MemberType switch
+                new (target, animator, MilAnimation.SimplePartTo(toValue, duration, delay, easeFunction, easeType), info.MemberType switch
                 {
                     MemberTypes.Field => ((FieldInfo)info).FieldType,
                     MemberTypes.Property => ((PropertyInfo)info).PropertyType,
                     _ => null
                 }, info)
             });
-            return animation;
+            return animator;
         }
         
         public static MilInstantAnimator MileaseAdditive(this object target, string memberName, object startValue, 
@@ -74,24 +74,24 @@ public static MilInstantAnimator Milease(this object target, string memberName,
             float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In, 
             MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)
         {
-            var animation = new MilInstantAnimator();
+            var animator = new MilInstantAnimator();
             var type = target.GetType();
             var members = type.GetMember(memberName);
             if (members.Length == 0)
             {
                 throw new MilMemberNotFoundException(memberName);
             }
             var info = members[0];
-            animation.Collection.Add(new List<RuntimeAnimationPart>()
+            animator.Collection.Add(new List<RuntimeAnimationPart>()
             {
-                new (target, MilAnimation.SimplePart(startValue, delay, easeFunction, easeType, blendingMode), info.MemberType switch
+                new (target, animator, MilAnimation.SimplePart(startValue, delay, easeFunction, easeType, blendingMode), info.MemberType switch
                 {
                     MemberTypes.Field => ((FieldInfo)info).FieldType,
                     MemberTypes.Property => ((PropertyInfo)info).PropertyType,
                     _ => null
                 }, info)
             });
-            return animation;
+            return animator;
         }
         
         public static MilInstantAnimator MileaseAdditive(this object target, string memberName, object startValue, 
@@ -104,47 +104,47 @@ public static MilInstantAnimator Milease(this object target, string memberName,
             object toValue, float duration, float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad, 
             EaseType easeType = EaseType.In, MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)
         {
-            var animation = new MilInstantAnimator();
+            var animator = new MilInstantAnimator();
             var type = target.GetType();
             var members = type.GetMember(memberName);
             if (members.Length == 0)
             {
                 throw new MilMemberNotFoundException(memberName);
             }
             var info = members[0];
-            animation.Collection.Add(new List<RuntimeAnimationPart>()
+            animator.Collection.Add(new List<RuntimeAnimationPart>()
             {
-                new (target, MilAnimation.SimplePart(startValue, toValue, duration, delay, easeFunction, easeType, blendingMode), info.MemberType switch
+                new (target, animator, MilAnimation.SimplePart(startValue, toValue, duration, delay, easeFunction, easeType, blendingMode), info.MemberType switch
                 {
                     MemberTypes.Field => ((FieldInfo)info).FieldType,
                     MemberTypes.Property => ((PropertyInfo)info).PropertyType,
                     _ => null
                 }, info)
             });
-            return animation;
+            return animator;
         }
         
         public static MilInstantAnimator Milease(this object target, string memberName, params MilAnimation.AnimationPart[] animations)
         {
-            var animation = new MilInstantAnimator();
+            var animator = new MilInstantAnimator();
             var type = target.GetType();
             var members = type.GetMember(memberName);
             if (members.Length == 0)
             {
                 throw new MilMemberNotFoundException(memberName);
             }
             var info = members[0];
-            animation.Collection.Add(
+            animator.Collection.Add(
                 animations.Select(x => 
-                        new RuntimeAnimationPart(target, x, info.MemberType switch
+                        new RuntimeAnimationPart(target, animator, x, info.MemberType switch
                         {
                             MemberTypes.Field => ((FieldInfo)info).FieldType,
                             MemberTypes.Property => ((PropertyInfo)info).PropertyType,
                             _ => null
                         }, info)
                     ).ToList()
                 );
-            return animation;
+            return animator;
         }
     }
 }
diff --git a/Scripts/Milease/Utils/HandleFunction.cs b/Scripts/Milease/Utils/HandleFunction.cs
@@ -6,21 +6,21 @@ namespace Milease.Utils
 {
     public static class HandleFunction
     {
-        public static void Hide(object o, float t)
+        public static void Hide(MilHandleFunctionArgs e)
         {
-            (o as GameObject)!.SetActive(t < 1f);
+            e.GetTarget<GameObject>().SetActive(e.Progress < 1f);
         }
-        public static void Show(object o, float t)
+        public static void Show(MilHandleFunctionArgs e)
         {
-            (o as GameObject)!.SetActive(t >= 1f);
+            e.GetTarget<GameObject>().SetActive(e.Progress >= 1f);
         }
-        public static void DeativeWhenReset(object o, float t)
+        public static void DeativeWhenReset(MilHandleFunctionArgs e)
         {
-            (o as GameObject)!.SetActive(false);
+            e.GetTarget<GameObject>().SetActive(false);
         }
-        public static void ActiveWhenReset(object o, float t)
+        public static void ActiveWhenReset(MilHandleFunctionArgs e)
         {
-            (o as GameObject)!.SetActive(true);
+            e.GetTarget<GameObject>().SetActive(true);
         }
 
         public static MileaseHandleFunction AutoActiveReset(GameObject go)
diff --git a/~Document/1. Instant Animator.md b/~Document/1. Instant Animator.md
@@ -108,10 +108,10 @@ animator.Reset(mode);
 Implement the following delegate to create custom animations:
 
 ```c#
-delegate void MileaseHandleFunction(object target, float progress);
+delegate void MileaseHandleFunction(MilHandleFunctionArgs e);
 ```
 
-`target` is the object being animated, and `progress` is the eased progress of the animation, ranging approximately from [0.0, 1.0].
+Call `e.GetTarget<T>()` to get the object being animated, and `e.Progress` is the eased progress of the animation, ranging approximately from [0.0, 1.0].
 
 To create a custom animation with `Milease`:
 
@@ -152,11 +152,11 @@ var animation =
                 Text.Milease(nameof(Text.text), "Start!", "Finish!", 1f)
             )
             .Then(
-                Text.Milease((o, p) =>
+                Text.Milease((e) =>
                 {
-                    var text = o as TMP_Text;
-                    text.text = $"Hide after {((1f - p) * 2f):F1}s...";
-                }, null,2f, 0f, EaseFunction.Linear)
+                    var text = e.GetTarget<TMP_Text>();
+                    text.text = $"Hide after {((1f - e.Progress) * 2f):F1}s...";
+                }, null, 2f, 0f, EaseFunction.Linear)
             )
             .Then(
                 Text.gameObject.Milease(HandleFunction.Hide, HandleFunction.AutoActiveReset(Text.gameObject), 0f)
diff --git a/~Document/1. 即时动画机.md b/~Document/1. 即时动画机.md
@@ -108,10 +108,10 @@ animator.Reset(mode);
 通过实现以下委托来实现：
 
 ```c#
-delegate void MileaseHandleFunction(object target, float progress);
+delegate void MileaseHandleFunction(MilHandleFunctionArgs e);
 ```
 
-`target` 为目标物体，`progress` 为动画进度（经过缓动处理后的进行），范围大约是[0.0, 1.0]。
+调用`e.GetTarget<T>()` 获取目标物体，`e.Progress` 为动画进度（经过缓动处理后的进行），范围大约是[0.0, 1.0]。
 
 使用`Milease`创建自定义动画：
 
@@ -152,11 +152,11 @@ var animation =
                 Text.Milease(nameof(Text.text), "Start!", "Finish!", 1f)
             )
             .Then(
-                Text.Milease((o, p) =>
+                Text.Milease((e) =>
                 {
-                    var text = o as TMP_Text;
-                    text.text = $"Hide after {((1f - p) * 2f):F1}s...";
-                }, null,2f, 0f, EaseFunction.Linear)
+                    var text = e.GetTarget<TMP_Text>();
+                    text.text = $"Hide after {((1f - e.Progress) * 2f):F1}s...";
+                }, null, 2f, 0f, EaseFunction.Linear)
             )
             .Then(
                 Text.gameObject.Milease(HandleFunction.Hide, HandleFunction.AutoActiveReset(Text.gameObject), 0f)

Original file line number	Diff line number	Diff line change
`@@ -64,11 +64,11 @@ var animation =`
`64`	`64`	`Text.Milease(nameof(Text.text), "Start!", "Finish!", 1f)`
`65`	`65`	`)`
`66`	`66`	`.Then(`
`67`		`- Text.Milease((o, p) =>`
	`67`	`+ Text.Milease((e) =>`
`68`	`68`	`{`
`69`		`- var text = o as TMP_Text;`
`70`		`- text.text = $"Hide after {((1f - p) * 2f):F1}s...";`
`71`		`- }, null,2f, 0f, EaseFunction.Linear)`
	`69`	`+ var text = e.GetTarget<TMP_Text>();`
	`70`	`+ text.text = $"Hide after {((1f - e.Progress) * 2f):F1}s...";`
	`71`	`+ }, null, 2f, 0f, EaseFunction.Linear)`
`72`	`72`	`)`
`73`	`73`	`.Then(`
`74`	`74`	`Text.gameObject.Milease(HandleFunction.Hide, HandleFunction.AutoActiveReset(Text.gameObject), 0f)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`
`7`	`7`	`namespace Milease.Core.Animation`
`8`	`8`	`{`
`9`		`- public delegate void MileaseHandleFunction(object target, float progress);`
`10`	`9`	`public class MilAnimation : ScriptableObject`
`11`	`10`	`{`
`12`	`11`	`public enum BlendingMode`
`@@ -107,7 +106,7 @@ public static AnimationPart SimplePart(object startValue, object toValue, float`
`107`	`106`	`};`
`108`	`107`	`}`
`109`	`108`
`110`		`- internal static AnimationPart SimplePart(MileaseHandleFunction handleFunction, MileaseHandleFunction resetFunction, float duration, float delay = 0f,`
	`109`	`+ internal static AnimationPart SimplePart(float duration, float delay = 0f,`
`111`	`110`	`EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In, BlendingMode blendingMode = BlendingMode.Default)`
`112`	`111`	`{`
`113`	`112`	`return new AnimationPart()`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace Milease.Utils`
`17`	`17`	`public static class MilInstantAnimatorExtension`
`18`	`18`	`{`
`19`	`19`	`public static MilInstantAnimator AsMileaseKeyEvent(this Action action, float delay = 0f)`
`20`		`- => Milease(action, (_, _) => action.Invoke(), null, 0f, delay);`
	`20`	`+ => Milease(action, (_) => action.Invoke(), null, 0f, delay);`
`21`	`21`
`22`	`22`	`public static MilInstantAnimator AsMileaseHandleFunction(this MileaseHandleFunction func, float duration, float delay = 0f)`
`23`	`23`	`=> Milease(func, func, null, duration, delay);`
`@@ -32,37 +32,37 @@ public static MilInstantAnimator Milease(this object target, MileaseHandleFuncti`
`32`	`32`	`EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In,`
`33`	`33`	`MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)`
`34`	`34`	`{`
`35`		`- var animation = new MilInstantAnimator();`
`36`		`- var ani = MilAnimation.SimplePart(handleFunction, resetFunction, duration, delay, easeFunction, easeType, blendingMode);`
`37`		`- animation.Collection.Add(new List<RuntimeAnimationPart>()`
	`35`	`+ var animator = new MilInstantAnimator();`
	`36`	`+ var ani = MilAnimation.SimplePart(duration, delay, easeFunction, easeType, blendingMode);`
	`37`	`+ animator.Collection.Add(new List<RuntimeAnimationPart>()`
`38`	`38`	`{`
`39`		`- new (target, ani, handleFunction, resetFunction)`
	`39`	`+ new (target, animator, ani, handleFunction, resetFunction)`
`40`	`40`	`});`
`41`		`- return animation;`
	`41`	`+ return animator;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public static MilInstantAnimator MileaseTo(this object target, string memberName, object toValue,`
`45`	`45`	`float duration, float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad,`
`46`	`46`	`EaseType easeType = EaseType.In)`
`47`	`47`	`{`
`48`		`- var animation = new MilInstantAnimator();`
	`48`	`+ var animator = new MilInstantAnimator();`
`49`	`49`	`var type = target.GetType();`
`50`	`50`	`var members = type.GetMember(memberName);`
`51`	`51`	`if (members.Length == 0)`
`52`	`52`	`{`
`53`	`53`	`throw new MilMemberNotFoundException(memberName);`
`54`	`54`	`}`
`55`	`55`	`var info = members[0];`
`56`		`- animation.Collection.Add(new List<RuntimeAnimationPart>()`
	`56`	`+ animator.Collection.Add(new List<RuntimeAnimationPart>()`
`57`	`57`	`{`
`58`		`- new (target, MilAnimation.SimplePartTo(toValue, duration, delay, easeFunction, easeType), info.MemberType switch`
	`58`	`+ new (target, animator, MilAnimation.SimplePartTo(toValue, duration, delay, easeFunction, easeType), info.MemberType switch`
`59`	`59`	`{`
`60`	`60`	`MemberTypes.Field => ((FieldInfo)info).FieldType,`
`61`	`61`	`MemberTypes.Property => ((PropertyInfo)info).PropertyType,`
`62`	`62`	`_ => null`
`63`	`63`	`}, info)`
`64`	`64`	`});`
`65`		`- return animation;`
	`65`	`+ return animator;`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`public static MilInstantAnimator MileaseAdditive(this object target, string memberName, object startValue,`
`@@ -74,24 +74,24 @@ public static MilInstantAnimator Milease(this object target, string memberName,`
`74`	`74`	`float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad, EaseType easeType = EaseType.In,`
`75`	`75`	`MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)`
`76`	`76`	`{`
`77`		`- var animation = new MilInstantAnimator();`
	`77`	`+ var animator = new MilInstantAnimator();`
`78`	`78`	`var type = target.GetType();`
`79`	`79`	`var members = type.GetMember(memberName);`
`80`	`80`	`if (members.Length == 0)`
`81`	`81`	`{`
`82`	`82`	`throw new MilMemberNotFoundException(memberName);`
`83`	`83`	`}`
`84`	`84`	`var info = members[0];`
`85`		`- animation.Collection.Add(new List<RuntimeAnimationPart>()`
	`85`	`+ animator.Collection.Add(new List<RuntimeAnimationPart>()`
`86`	`86`	`{`
`87`		`- new (target, MilAnimation.SimplePart(startValue, delay, easeFunction, easeType, blendingMode), info.MemberType switch`
	`87`	`+ new (target, animator, MilAnimation.SimplePart(startValue, delay, easeFunction, easeType, blendingMode), info.MemberType switch`
`88`	`88`	`{`
`89`	`89`	`MemberTypes.Field => ((FieldInfo)info).FieldType,`
`90`	`90`	`MemberTypes.Property => ((PropertyInfo)info).PropertyType,`
`91`	`91`	`_ => null`
`92`	`92`	`}, info)`
`93`	`93`	`});`
`94`		`- return animation;`
	`94`	`+ return animator;`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`public static MilInstantAnimator MileaseAdditive(this object target, string memberName, object startValue,`
`@@ -104,47 +104,47 @@ public static MilInstantAnimator Milease(this object target, string memberName,`
`104`	`104`	`object toValue, float duration, float delay = 0f, EaseFunction easeFunction = EaseFunction.Quad,`
`105`	`105`	`EaseType easeType = EaseType.In, MilAnimation.BlendingMode blendingMode = MilAnimation.BlendingMode.Default)`
`106`	`106`	`{`
`107`		`- var animation = new MilInstantAnimator();`
	`107`	`+ var animator = new MilInstantAnimator();`
`108`	`108`	`var type = target.GetType();`
`109`	`109`	`var members = type.GetMember(memberName);`
`110`	`110`	`if (members.Length == 0)`
`111`	`111`	`{`
`112`	`112`	`throw new MilMemberNotFoundException(memberName);`
`113`	`113`	`}`
`114`	`114`	`var info = members[0];`
`115`		`- animation.Collection.Add(new List<RuntimeAnimationPart>()`
	`115`	`+ animator.Collection.Add(new List<RuntimeAnimationPart>()`
`116`	`116`	`{`
`117`		`- new (target, MilAnimation.SimplePart(startValue, toValue, duration, delay, easeFunction, easeType, blendingMode), info.MemberType switch`
	`117`	`+ new (target, animator, MilAnimation.SimplePart(startValue, toValue, duration, delay, easeFunction, easeType, blendingMode), info.MemberType switch`
`118`	`118`	`{`
`119`	`119`	`MemberTypes.Field => ((FieldInfo)info).FieldType,`
`120`	`120`	`MemberTypes.Property => ((PropertyInfo)info).PropertyType,`
`121`	`121`	`_ => null`
`122`	`122`	`}, info)`
`123`	`123`	`});`
`124`		`- return animation;`
	`124`	`+ return animator;`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`public static MilInstantAnimator Milease(this object target, string memberName, params MilAnimation.AnimationPart[] animations)`
`128`	`128`	`{`
`129`		`- var animation = new MilInstantAnimator();`
	`129`	`+ var animator = new MilInstantAnimator();`
`130`	`130`	`var type = target.GetType();`
`131`	`131`	`var members = type.GetMember(memberName);`
`132`	`132`	`if (members.Length == 0)`
`133`	`133`	`{`
`134`	`134`	`throw new MilMemberNotFoundException(memberName);`
`135`	`135`	`}`
`136`	`136`	`var info = members[0];`
`137`		`- animation.Collection.Add(`
	`137`	`+ animator.Collection.Add(`
`138`	`138`	`animations.Select(x =>`
`139`		`- new RuntimeAnimationPart(target, x, info.MemberType switch`
	`139`	`+ new RuntimeAnimationPart(target, animator, x, info.MemberType switch`
`140`	`140`	`{`
`141`	`141`	`MemberTypes.Field => ((FieldInfo)info).FieldType,`
`142`	`142`	`MemberTypes.Property => ((PropertyInfo)info).PropertyType,`
`143`	`143`	`_ => null`
`144`	`144`	`}, info)`
`145`	`145`	`).ToList()`
`146`	`146`	`);`
`147`		`- return animation;`
	`147`	`+ return animator;`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,21 +6,21 @@ namespace Milease.Utils`
`6`	`6`	`{`
`7`	`7`	`public static class HandleFunction`
`8`	`8`	`{`
`9`		`- public static void Hide(object o, float t)`
	`9`	`+ public static void Hide(MilHandleFunctionArgs e)`
`10`	`10`	`{`
`11`		`- (o as GameObject)!.SetActive(t < 1f);`
	`11`	`+ e.GetTarget<GameObject>().SetActive(e.Progress < 1f);`
`12`	`12`	`}`
`13`		`- public static void Show(object o, float t)`
	`13`	`+ public static void Show(MilHandleFunctionArgs e)`
`14`	`14`	`{`
`15`		`- (o as GameObject)!.SetActive(t >= 1f);`
	`15`	`+ e.GetTarget<GameObject>().SetActive(e.Progress >= 1f);`
`16`	`16`	`}`
`17`		`- public static void DeativeWhenReset(object o, float t)`
	`17`	`+ public static void DeativeWhenReset(MilHandleFunctionArgs e)`
`18`	`18`	`{`
`19`		`- (o as GameObject)!.SetActive(false);`
	`19`	`+ e.GetTarget<GameObject>().SetActive(false);`
`20`	`20`	`}`
`21`		`- public static void ActiveWhenReset(object o, float t)`
	`21`	`+ public static void ActiveWhenReset(MilHandleFunctionArgs e)`
`22`	`22`	`{`
`23`		`- (o as GameObject)!.SetActive(true);`
	`23`	`+ e.GetTarget<GameObject>().SetActive(true);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public static MileaseHandleFunction AutoActiveReset(GameObject go)`