Merge branch 'master' of http://192.168.123.2:3000/fort23/XY001

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7448326a5172e48ada65ceea1fcacd5a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/EditorMotionScheduler.cs

@@ -0,0 +1,13 @@
+namespace LitMotion.Editor
+{
+    /// <summary>
+    /// Schedulers available in Editor.
+    /// </summary>
+    public static class EditorMotionScheduler
+    {
+        /// <summary>
+        /// Scheduler that updates motion at EditorApplication.update.
+        /// </summary>
+        public static readonly IMotionScheduler Update = new EditorUpdateMotionScheduler();
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/EditorMotionScheduler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 107e848b310f2422da759f4ecfbf6591
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/EditorUpdateMotionScheduler.cs

@@ -0,0 +1,17 @@
+using UnityEditor;
+
+namespace LitMotion.Editor
+{
+    internal sealed class EditorUpdateMotionScheduler : IMotionScheduler
+    {
+        public double Time => EditorApplication.timeSinceStartup;
+
+        public MotionHandle Schedule<TValue, TOptions, TAdapter>(ref MotionData<TValue, TOptions> data, ref MotionCallbackData callbackData)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            return EditorMotionDispatcher.Schedule<TValue, TOptions, TAdapter>(data, callbackData);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/EditorUpdateMotionScheduler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b031264947f0d44ffb3f491ff4e4e340
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/LitMotion.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "LitMotion.Editor",
+    "rootNamespace": "LitMotion.Editor",
+    "references": [
+        "GUID:3b570a5146f9d4f0fa107ed4559471a3"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/LitMotion.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8c41f684b6199433cbfc54bfc4a1c78e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/MotionTrackerTreeView.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+
+namespace LitMotion.Editor
+{
+    internal sealed class MotionTrackerViewItem : TreeViewItem
+    {
+        public MotionTrackerViewItem(int id) : base(id) { }
+
+        static readonly Regex removeHref = new("<a href.+>(.+)</a>", RegexOptions.Compiled);
+
+        public string MotionType { get; set; }
+        public string SchedulerType { get; set; }
+        public string Elapsed { get; set; }
+
+        string position;
+        public string Position
+        {
+            get { return position; }
+            set
+            {
+                position = value;
+                PositionFirstLine = value == null ? string.Empty : GetFirstLine(position);
+            }
+        }
+
+        public string PositionFirstLine { get; private set; }
+
+        static string GetFirstLine(string str)
+        {
+            var sb = new StringBuilder();
+            for (int i = 0; i < str.Length; i++)
+            {
+                if (str[i] == '\r' || str[i] == '\n')
+                {
+                    break;
+                }
+                sb.Append(str[i]);
+            }
+
+            return removeHref.Replace(sb.ToString(), "$1");
+        }
+    }
+
+    internal sealed class MotionTrackerTreeView : TreeView
+    {
+        const string sortedColumnIndexStateKey = "MotionTrackerTreeView_sortedColumnIndex";
+
+        public IReadOnlyList<TreeViewItem> CurrentBindingItems;
+
+        public MotionTrackerTreeView()
+            : this(new TreeViewState(), new MultiColumnHeader(new MultiColumnHeaderState(new[]
+            {
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Motion Type"), width = 55},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Scheduler"), width = 25},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Elapsed"), width = 15},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Stack Trace")},
+            })))
+        {
+
+        }
+
+        MotionTrackerTreeView(TreeViewState state, MultiColumnHeader header)
+            : base(state, header)
+        {
+            rowHeight = 20;
+            showAlternatingRowBackgrounds = true;
+            showBorder = true;
+            header.sortingChanged += HeaderSortingChanged;
+
+            header.ResizeToFit();
+            Reload();
+
+            header.sortedColumnIndex = SessionState.GetInt(sortedColumnIndexStateKey, 1);
+        }
+
+        public void ReloadAndSort()
+        {
+            var currentSelected = state.selectedIDs;
+            Reload();
+            HeaderSortingChanged(multiColumnHeader);
+            state.selectedIDs = currentSelected;
+        }
+
+        void HeaderSortingChanged(MultiColumnHeader multiColumnHeader)
+        {
+            SessionState.SetInt(sortedColumnIndexStateKey, multiColumnHeader.sortedColumnIndex);
+            var index = multiColumnHeader.sortedColumnIndex;
+            var ascending = multiColumnHeader.IsSortedAscending(multiColumnHeader.sortedColumnIndex);
+
+            var items = rootItem.children.Cast<MotionTrackerViewItem>();
+            IOrderedEnumerable<MotionTrackerViewItem> orderedEnumerable = index switch
+            {
+                0 => ascending ? items.OrderBy(item => item.MotionType) : items.OrderByDescending(item => item.MotionType),
+                1 => ascending ? items.OrderBy(item => item.SchedulerType) : items.OrderByDescending(item => item.SchedulerType),
+                2 => ascending ? items.OrderBy(item => double.Parse(item.Elapsed)) : items.OrderByDescending(item => double.Parse(item.Elapsed)),
+                3 => ascending ? items.OrderBy(item => item.Position) : items.OrderByDescending(item => item.PositionFirstLine),
+                _ => throw new ArgumentOutOfRangeException(nameof(index), index, null),
+            };
+            CurrentBindingItems = rootItem.children = orderedEnumerable.Cast<TreeViewItem>().ToList();
+            BuildRows(rootItem);
+        }
+
+        static string GetSchedulerName(IMotionScheduler scheduler, bool isCreatedOnEditor)
+        {
+            static string GetTimeKindName(MotionTimeKind motionTimeKind)
+            {
+                return motionTimeKind switch
+                {
+                    MotionTimeKind.Time => "",
+                    MotionTimeKind.UnscaledTime => "IgnoreTimeScale",
+                    MotionTimeKind.Realtime => "Realtime",
+                    _ => null
+                };
+            }
+            if (scheduler == null)
+            {
+                if (isCreatedOnEditor)
+                {
+                    scheduler = MotionScheduler.DefaultScheduler;
+                }
+                else
+                {
+                    scheduler = EditorMotionScheduler.Update;
+                }
+            }
+
+            return scheduler switch
+            {
+                PlayerLoopMotionScheduler loopMotionScheduler => loopMotionScheduler.playerLoopTiming.ToString() + GetTimeKindName(loopMotionScheduler.timeKind),
+                ManualMotionScheduler => "Manual",
+                EditorUpdateMotionScheduler => "EditorUpdate",
+                _ => scheduler.GetType()?.Name,
+            };
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem { depth = -1 };
+            var children = new List<TreeViewItem>();
+
+            var id = 0;
+            foreach (var tracking in MotionTracker.Items)
+            {
+                children.Add(new MotionTrackerViewItem(id)
+                {
+                    MotionType = $"[{tracking.ValueType.Name}, {tracking.OptionsType.Name}, {tracking.AdapterType.Name}]",
+                    SchedulerType = GetSchedulerName(tracking.Scheduler, tracking.CreatedOnEditor),
+                    Elapsed = (DateTime.UtcNow - tracking.CreationTime).TotalSeconds.ToString("00.00"),
+                    Position = tracking.StackTrace?.AddHyperLink()
+                });
+                id++;
+            }
+
+            CurrentBindingItems = children;
+            root.children = CurrentBindingItems as List<TreeViewItem>;
+            return root;
+        }
+
+        protected override bool CanMultiSelect(TreeViewItem item)
+        {
+            return false;
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item as MotionTrackerViewItem;
+
+            for (var visibleColumnIndex = 0; visibleColumnIndex < args.GetNumVisibleColumns(); visibleColumnIndex++)
+            {
+                var rect = args.GetCellRect(visibleColumnIndex);
+                var columnIndex = args.GetColumn(visibleColumnIndex);
+
+                var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
+                labelStyle.alignment = TextAnchor.MiddleLeft;
+                switch (columnIndex)
+                {
+                    case 0:
+                        EditorGUI.LabelField(rect, item.MotionType, labelStyle);
+                        break;
+                    case 1:
+                        EditorGUI.LabelField(rect, item.SchedulerType, labelStyle);
+                        break;
+                    case 2:
+                        EditorGUI.LabelField(rect, item.Elapsed, labelStyle);
+                        break;
+                    case 3:
+                        EditorGUI.LabelField(rect, item.PositionFirstLine, labelStyle);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(columnIndex), columnIndex, null);
+                }
+            }
+        }
+    }
+
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/MotionTrackerTreeView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f98e472bc5f104a6ca82d1332535dbd4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/MotionTrackerWindow.cs

@@ -0,0 +1,160 @@
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+
+namespace LitMotion.Editor
+{
+    /// <summary>
+    /// Editor window that displays a list of motions being tracked.
+    /// </summary>
+    public class MotionTrackerWindow : EditorWindow
+    {
+        static MotionTrackerWindow instance;
+
+        [MenuItem("Window/LitMotion/Motion Tracker")]
+        public static void OpenWindow()
+        {
+            if (instance != null) instance.Close();
+            GetWindow<MotionTrackerWindow>("Motion Tracker").Show();
+        }
+
+        static readonly GUILayoutOption[] EmptyLayoutOption = new GUILayoutOption[0];
+
+        MotionTrackerTreeView treeView;
+        object splitterState;
+
+        const string EnableTrackingPrefsKey = "LitMotion-MotionTracker-EnableTracking";
+        const string EnableStackTracePrefsKey = "LitMotion-MotionTracker-EnableStackTrace";
+
+        void OnEnable()
+        {
+            instance = this;
+            splitterState = SplitterGUILayout.CreateSplitterState(new float[] { 75f, 25f }, new int[] { 32, 32 }, null);
+            treeView = new MotionTrackerTreeView();
+            MotionTracker.EnableTracking = EditorPrefs.GetBool(EnableTrackingPrefsKey, false);
+            MotionTracker.EnableStackTrace = EditorPrefs.GetBool(EnableStackTracePrefsKey, false);
+        }
+
+        void OnGUI()
+        {
+            RenderHeadPanel();
+            SplitterGUILayout.BeginVerticalSplit(this.splitterState, EmptyLayoutOption);
+            RenderTable();
+            RenderDetailsPanel();
+            SplitterGUILayout.EndVerticalSplit();
+        }
+
+        static readonly GUIContent ClearHeadContent = EditorGUIUtility.TrTextContent(" Clear ");
+        static readonly GUIContent EnableTrackingHeadContent = EditorGUIUtility.TrTextContent("Enable Tracking");
+        static readonly GUIContent EnableStackTraceHeadContent = EditorGUIUtility.TrTextContent("Enable Stack Trace");
+
+        void RenderHeadPanel()
+        {
+            EditorGUILayout.BeginVertical(EmptyLayoutOption);
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, EmptyLayoutOption);
+
+            if (GUILayout.Toggle(MotionTracker.EnableTracking, EnableTrackingHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != MotionTracker.EnableTracking)
+            {
+                MotionTracker.EnableTracking = !MotionTracker.EnableTracking;
+                EditorPrefs.SetBool(EnableTrackingPrefsKey, MotionTracker.EnableTracking);
+            }
+
+            if (GUILayout.Toggle(MotionTracker.EnableStackTrace, EnableStackTraceHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != MotionTracker.EnableStackTrace)
+            {
+                MotionTracker.EnableStackTrace = !MotionTracker.EnableStackTrace;
+                EditorPrefs.SetBool(EnableStackTracePrefsKey, MotionTracker.EnableStackTrace);
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button(ClearHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption))
+            {
+                MotionTracker.Clear();
+                treeView.ReloadAndSort();
+                Repaint();
+            }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+        }
+
+        Vector2 tableScroll;
+        GUIStyle tableListStyle;
+
+        void RenderTable()
+        {
+            if (tableListStyle == null)
+            {
+                tableListStyle = new GUIStyle("CN Box");
+                tableListStyle.margin.top = 0;
+                tableListStyle.padding.left = 3;
+            }
+
+            EditorGUILayout.BeginVertical(tableListStyle, EmptyLayoutOption);
+
+            tableScroll = EditorGUILayout.BeginScrollView(this.tableScroll, new GUILayoutOption[]
+            {
+                GUILayout.ExpandWidth(true),
+                GUILayout.MaxWidth(2000f)
+            });
+            var controlRect = EditorGUILayout.GetControlRect(new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true)
+            });
+
+            treeView?.OnGUI(controlRect);
+
+            EditorGUILayout.EndScrollView();
+            EditorGUILayout.EndVertical();
+        }
+
+        static int interval;
+        void Update()
+        {
+            if (interval++ % 120 == 0)
+            {
+                treeView.ReloadAndSort();
+                Repaint();
+            }
+        }
+
+        static GUIStyle detailsStyle;
+        Vector2 detailsScroll;
+
+        void RenderDetailsPanel()
+        {
+            if (detailsStyle == null)
+            {
+                detailsStyle = new GUIStyle("CN Message")
+                {
+                    wordWrap = false,
+                    stretchHeight = true
+                };
+                detailsStyle.margin.right = 15;
+            }
+
+            string message = "";
+            var selected = treeView.state.selectedIDs;
+            if (selected.Count > 0)
+            {
+                var first = selected[0];
+                if (treeView.CurrentBindingItems.FirstOrDefault(x => x.id == first) is MotionTrackerViewItem item)
+                {
+                    message = item.Position;
+                }
+            }
+
+            detailsScroll = EditorGUILayout.BeginScrollView(this.detailsScroll, EmptyLayoutOption);
+            var vector = detailsStyle.CalcSize(new GUIContent(message));
+            EditorGUILayout.SelectableLabel(message, detailsStyle, new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true),
+                GUILayout.MinWidth(vector.x),
+                GUILayout.MinHeight(vector.y)
+            });
+            EditorGUILayout.EndScrollView();
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/MotionTrackerWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fea601067977b4583a9d5512902924b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/SplitterGUILayout.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEditor;
+
+namespace LitMotion.Editor
+{
+    internal static class SplitterGUILayout
+    {
+        static readonly BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
+
+        static readonly Lazy<Type> splitterStateType = new(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterState");
+            return type;
+        });
+
+        static readonly Lazy<ConstructorInfo> splitterStateCtor = new(() =>
+        {
+            var type = splitterStateType.Value;
+            return type.GetConstructor(flags, null, new Type[] { typeof(float[]), typeof(int[]), typeof(int[]) }, null);
+        });
+
+        static readonly Lazy<Type> splitterGUILayoutType = new(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterGUILayout");
+            return type;
+        });
+
+        static readonly Lazy<MethodInfo> beginVerticalSplit = new(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("BeginVerticalSplit", flags, null, new Type[] { splitterStateType.Value, typeof(GUILayoutOption[]) }, null);
+        });
+
+        static readonly Lazy<MethodInfo> endVerticalSplit = new(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("EndVerticalSplit", flags, null, Type.EmptyTypes, null);
+        });
+
+        public static object CreateSplitterState(float[] relativeSizes, int[] minSizes, int[] maxSizes)
+        {
+            return splitterStateCtor.Value.Invoke(new object[] { relativeSizes, minSizes, maxSizes });
+        }
+
+        public static void BeginVerticalSplit(object splitterState, params GUILayoutOption[] options)
+        {
+            beginVerticalSplit.Value.Invoke(null, new object[] { splitterState, options });
+        }
+
+        public static void EndVerticalSplit()
+        {
+            endVerticalSplit.Value.Invoke(null, Type.EmptyTypes);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/SplitterGUILayout.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 923b444fcf7c747f69e9d95170f17481
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/StackTraceHelper.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Security;
+using System.Text;
+using UnityEngine;
+
+namespace LitMotion.Editor
+{
+    internal static class StackTraceHelper
+    {
+        static readonly StringBuilder sb = new();
+
+        public static string AddHyperLink(this StackTrace stackTrace)
+        {
+            if (stackTrace == null) return "";
+
+            sb.Clear();
+            for (int i = 0; i < stackTrace.FrameCount; i++)
+            {
+                var sf = stackTrace.GetFrame(i);
+
+                if (sf.GetILOffset() != -1)
+                {
+                    string fileName = null;
+                    try
+                    {
+                        fileName = sf.GetFileName();
+                    }
+                    catch (NotSupportedException) { }
+                    catch (SecurityException) { }
+
+                    if (fileName != null)
+                    {
+                        sb.Append(' ');
+                        sb.AppendFormat(CultureInfo.InvariantCulture, "(at {0})", AppendHyperLink(fileName, sf.GetFileLineNumber().ToString()));
+                        sb.AppendLine();
+                    }
+                }
+            }
+            return sb.ToString();
+        }
+
+        static string AppendHyperLink(string path, string line)
+        {
+            var fi = new FileInfo(path);
+            if (fi.Directory == null)
+            {
+                return fi.Name;
+            }
+            else
+            {
+                var fname = fi.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(Application.dataPath, "");
+                var withAssetsPath = "Assets/" + fname;
+                return "<a href=\"" + withAssetsPath + "\" line=\"" + line + "\">" + withAssetsPath + ":" + line + "</a>";
+            }
+        }
+    }
+
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Editor/StackTraceHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 23ef76083ea944983ba18d0a87db9436
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0f124f99c512d45c3be295f2c664085d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 78976ec8f5b484120b429691f1ff54f0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/FixedStringMotionAdapters.cs

@@ -0,0 +1,83 @@
+using Unity.Collections;
+using Unity.Jobs;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<FixedString32Bytes, StringOptions, FixedString32BytesMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<FixedString64Bytes, StringOptions, FixedString64BytesMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<FixedString128Bytes, StringOptions, FixedString128BytesMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<FixedString512Bytes, StringOptions, FixedString512BytesMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<FixedString4096Bytes, StringOptions, FixedString4096BytesMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    public readonly struct FixedString32BytesMotionAdapter : IMotionAdapter<FixedString32Bytes, StringOptions>
+    {
+        public FixedString32Bytes Evaluate(ref FixedString32Bytes startValue, ref FixedString32Bytes endValue, ref StringOptions options, in MotionEvaluationContext context)
+        {
+            var start = startValue;
+            var end = endValue;
+            var customScrambleChars = options.CustomScrambleChars;
+            ref var randomState = ref options.RandomState;
+            if (randomState.state == 0) randomState = ref SharedRandom.Random;
+            FixedStringHelper.Interpolate(ref start, ref end, context.Progress, options.ScrambleMode, options.RichTextEnabled, ref randomState, ref customScrambleChars, out var result);
+            return result;
+        }
+    }
+
+    public readonly struct FixedString64BytesMotionAdapter : IMotionAdapter<FixedString64Bytes, StringOptions>
+    {
+        public FixedString64Bytes Evaluate(ref FixedString64Bytes startValue, ref FixedString64Bytes endValue, ref StringOptions options, in MotionEvaluationContext context)
+        {
+            var start = startValue;
+            var end = endValue;
+            var customScrambleChars = options.CustomScrambleChars;
+            ref var randomState = ref options.RandomState;
+            if (randomState.state == 0) randomState = ref SharedRandom.Random;
+            FixedStringHelper.Interpolate(ref start, ref end, context.Progress, options.ScrambleMode, options.RichTextEnabled, ref randomState, ref customScrambleChars, out var result);
+            return result;
+        }
+    }
+
+    public readonly struct FixedString128BytesMotionAdapter : IMotionAdapter<FixedString128Bytes, StringOptions>
+    {
+        public FixedString128Bytes Evaluate(ref FixedString128Bytes startValue, ref FixedString128Bytes endValue, ref StringOptions options, in MotionEvaluationContext context)
+        {
+            var start = startValue;
+            var end = endValue;
+            var customScrambleChars = options.CustomScrambleChars;
+            ref var randomState = ref options.RandomState;
+            if (randomState.state == 0) randomState = ref SharedRandom.Random;
+            FixedStringHelper.Interpolate(ref start, ref end, context.Progress, options.ScrambleMode, options.RichTextEnabled, ref randomState, ref customScrambleChars, out var result);
+            return result;
+        }
+    }
+
+    public readonly struct FixedString512BytesMotionAdapter : IMotionAdapter<FixedString512Bytes, StringOptions>
+    {
+        public FixedString512Bytes Evaluate(ref FixedString512Bytes startValue, ref FixedString512Bytes endValue, ref StringOptions options, in MotionEvaluationContext context)
+        {
+            var start = startValue;
+            var end = endValue;
+            var customScrambleChars = options.CustomScrambleChars;
+            ref var randomState = ref options.RandomState;
+            if (randomState.state == 0) randomState = ref SharedRandom.Random;
+            FixedStringHelper.Interpolate(ref start, ref end, context.Progress, options.ScrambleMode, options.RichTextEnabled, ref randomState, ref customScrambleChars, out var result);
+            return result;
+        }
+    }
+
+    public readonly struct FixedString4096BytesMotionAdapter : IMotionAdapter<FixedString4096Bytes, StringOptions>
+    {
+        public FixedString4096Bytes Evaluate(ref FixedString4096Bytes startValue, ref FixedString4096Bytes endValue, ref StringOptions options, in MotionEvaluationContext context)
+        {
+            var start = startValue;
+            var end = endValue;
+            var customScrambleChars = options.CustomScrambleChars;
+            ref var randomState = ref options.RandomState;
+            if (randomState.state == 0) randomState = ref SharedRandom.Random;
+            FixedStringHelper.Interpolate(ref start, ref end, context.Progress, options.ScrambleMode, options.RichTextEnabled, ref randomState, ref customScrambleChars, out var result);
+            return result;
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/FixedStringMotionAdapters.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 42ad682500fb144858faa8326f200c98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/PrimitiveMotionAdapters.cs

@@ -0,0 +1,61 @@
+using Unity.Jobs;
+using Unity.Mathematics;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<float, NoOptions, FloatMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<double, NoOptions, DoubleMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<int, IntegerOptions, IntMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<long, IntegerOptions, LongMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    public readonly struct FloatMotionAdapter : IMotionAdapter<float, NoOptions>
+    {
+        public float Evaluate(ref float startValue, ref float endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return math.lerp(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct DoubleMotionAdapter : IMotionAdapter<double, NoOptions>
+    {
+        public double Evaluate(ref double startValue, ref double endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return math.lerp(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct IntMotionAdapter : IMotionAdapter<int, IntegerOptions>
+    {
+        public int Evaluate(ref int startValue, ref int endValue, ref IntegerOptions options, in MotionEvaluationContext context)
+        {
+            var value = math.lerp(startValue, endValue, context.Progress);
+
+            return options.RoundingMode switch
+            {
+                RoundingMode.AwayFromZero => value >= 0f ? (int)math.ceil(value) : (int)math.floor(value),
+                RoundingMode.ToZero => (int)math.trunc(value),
+                RoundingMode.ToPositiveInfinity => (int)math.ceil(value),
+                RoundingMode.ToNegativeInfinity => (int)math.floor(value),
+                _ => (int)math.round(value),
+            };
+        }
+    }
+    public readonly struct LongMotionAdapter : IMotionAdapter<long, IntegerOptions>
+    {
+        public long Evaluate(ref long startValue, ref long endValue, ref IntegerOptions options, in MotionEvaluationContext context)
+        {
+            var value = math.lerp((double)startValue, endValue, context.Progress);
+
+            return options.RoundingMode switch
+            {
+                RoundingMode.AwayFromZero => value >= 0f ? (long)math.ceil(value) : (long)math.floor(value),
+                RoundingMode.ToZero => (long)math.trunc(value),
+                RoundingMode.ToPositiveInfinity => (long)math.ceil(value),
+                RoundingMode.ToNegativeInfinity => (long)math.floor(value),
+                _ => (long)math.round(value),
+            };
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/PrimitiveMotionAdapters.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1882c1598b0a54f46a356e68810d6697
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/PunchMotionAdapters.cs

@@ -0,0 +1,40 @@
+using Unity.Jobs;
+using UnityEngine;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<float, PunchOptions, FloatPunchMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector2, PunchOptions, Vector2PunchMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector3, PunchOptions, Vector3PunchMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    // Note: Punch motion uses startValue as offset and endValue as vibration strength.
+
+    public readonly struct FloatPunchMotionAdapter : IMotionAdapter<float, PunchOptions>
+    {
+        public float Evaluate(ref float startValue, ref float endValue, ref PunchOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var result);
+            return startValue + result;
+        }
+    }
+
+    public readonly struct Vector2PunchMotionAdapter : IMotionAdapter<Vector2, PunchOptions>
+    {
+        public Vector2 Evaluate(ref Vector2 startValue, ref Vector2 endValue, ref PunchOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var result);
+            return startValue + result;
+        }
+    }
+
+    public readonly struct Vector3PunchMotionAdapter : IMotionAdapter<Vector3, PunchOptions>
+    {
+        public Vector3 Evaluate(ref Vector3 startValue, ref Vector3 endValue, ref PunchOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var result);
+            return startValue + result;
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/PunchMotionAdapters.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 383cffcddd9234d6ab7755c50bdd09b8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/ShakeMotionAdapters.cs

@@ -0,0 +1,67 @@
+using Unity.Jobs;
+using UnityEngine;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<float, ShakeOptions, FloatShakeMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector2, ShakeOptions, Vector2ShakeMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector3, ShakeOptions, Vector3ShakeMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    // Note: Shake motion uses startValue as offset and endValue as vibration strength.
+
+    public readonly struct FloatShakeMotionAdapter : IMotionAdapter<float, ShakeOptions>
+    {
+        public float Evaluate(ref float startValue, ref float endValue, ref ShakeOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var s);
+            float multipliar;
+            if (options.RandomState.state == 0)
+            {
+                multipliar = SharedRandom.Random.NextFloat(-1f, 1f);
+            }
+            else
+            {
+                multipliar = options.RandomState.NextFloat(-1f, 1f);
+            }
+            return startValue + s * multipliar;
+        }
+    }
+
+    public readonly struct Vector2ShakeMotionAdapter : IMotionAdapter<Vector2, ShakeOptions>
+    {
+        public Vector2 Evaluate(ref Vector2 startValue, ref Vector2 endValue, ref ShakeOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var s);
+            Vector2 multipliar;
+            if (options.RandomState.state == 0)
+            {
+                multipliar = new Vector2(SharedRandom.Random.NextFloat(-1f, 1f), SharedRandom.Random.NextFloat(-1f, 1f));
+            }
+            else
+            {
+                multipliar = new Vector2(options.RandomState.NextFloat(-1f, 1f), options.RandomState.NextFloat(-1f, 1f));
+            }
+            return startValue + new Vector2(s.x * multipliar.x, s.y * multipliar.y);
+        }
+    }
+
+    public readonly struct Vector3ShakeMotionAdapter : IMotionAdapter<Vector3, ShakeOptions>
+    {
+        public Vector3 Evaluate(ref Vector3 startValue, ref Vector3 endValue, ref ShakeOptions options, in MotionEvaluationContext context)
+        {
+            VibrationHelper.EvaluateStrength(endValue, options.Frequency, options.DampingRatio, context.Progress, out var s);
+            Vector3 multipliar;
+            if (options.RandomState.state == 0)
+            {
+                multipliar = new Vector3(SharedRandom.Random.NextFloat(-1f, 1f), SharedRandom.Random.NextFloat(-1f, 1f), SharedRandom.Random.NextFloat(-1f, 1f));
+            }
+            else
+            {
+                multipliar = new Vector3(options.RandomState.NextFloat(-1f, 1f), options.RandomState.NextFloat(-1f, 1f), options.RandomState.NextFloat(-1f, 1f));
+            }
+            return startValue + new Vector3(s.x * multipliar.x, s.y * multipliar.y, s.z * multipliar.z);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/ShakeMotionAdapters.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 602341aa9b1c34fd5a9b80497b8f3752
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/UnityMotionAdapter.cs

@@ -0,0 +1,68 @@
+using Unity.Jobs;
+using Unity.Mathematics;
+using UnityEngine;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector2, NoOptions, Vector2MotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector3, NoOptions, Vector3MotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector4, NoOptions, Vector4MotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Quaternion, NoOptions, QuaternionMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Color, NoOptions, ColorMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Rect, NoOptions, RectMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    public readonly struct Vector2MotionAdapter : IMotionAdapter<Vector2, NoOptions>
+    {
+        public Vector2 Evaluate(ref Vector2 startValue, ref Vector2 endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return Vector2.LerpUnclamped(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct Vector3MotionAdapter : IMotionAdapter<Vector3, NoOptions>
+    {
+        public Vector3 Evaluate(ref Vector3 startValue, ref Vector3 endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return Vector3.LerpUnclamped(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct Vector4MotionAdapter : IMotionAdapter<Vector4, NoOptions>
+    {
+        public Vector4 Evaluate(ref Vector4 startValue, ref Vector4 endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return Vector4.LerpUnclamped(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct QuaternionMotionAdapter : IMotionAdapter<Quaternion, NoOptions>
+    {
+        public Quaternion Evaluate(ref Quaternion startValue, ref Quaternion endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return Quaternion.LerpUnclamped(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct ColorMotionAdapter : IMotionAdapter<Color, NoOptions>
+    {
+        public Color Evaluate(ref Color startValue, ref Color endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            return Color.LerpUnclamped(startValue, endValue, context.Progress);
+        }
+    }
+
+    public readonly struct RectMotionAdapter : IMotionAdapter<Rect, NoOptions>
+    {
+        public Rect Evaluate(ref Rect startValue, ref Rect endValue, ref NoOptions options, in MotionEvaluationContext context)
+        {
+            var x = math.lerp(startValue.x, endValue.x, context.Progress);
+            var y = math.lerp(startValue.y, endValue.y, context.Progress);
+            var width = math.lerp(startValue.width, endValue.width, context.Progress);
+            var height = math.lerp(startValue.height, endValue.height, context.Progress);
+
+            return new Rect(x, y, width, height);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Adapters/UnityMotionAdapter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0c4e616134ab4b299c602773c48431b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/AssemblyInfo.cs

@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("LitMotion.Extensions")]
+[assembly: InternalsVisibleTo("LitMotion.Editor")]
+[assembly: InternalsVisibleTo("LitMotion.Tests.Runtime")]

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/AssemblyInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e167de3ae8be64c438c07ea8274269c2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/CancelBehaviour.cs

@@ -0,0 +1,14 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Specifies the behavior when await is canceled.
+    /// </summary>
+    public enum CancelBehaviour
+    {
+        CancelAndCancelAwait,
+        CompleteAndCancelAwait,
+        CancelAwait,
+        Cancel,
+        Complete
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/CancelBehaviour.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50257f63263634fbbae1c181f16d4fb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 75237434138a84be7aa404c2b81d9ec5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/FastListCore.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LitMotion.Collections
+{
+    /// <summary>
+    /// A list of minimal features. Note that it is NOT thread-safe and must NOT be marked readonly as it is a mutable struct.
+    /// </summary>
+    /// <typeparam name="T">Element type</typeparam>
+    [StructLayout(LayoutKind.Auto)]
+    public struct FastListCore<T>
+    {
+        const int InitialCapacity = 8;
+
+        public static readonly FastListCore<T> Empty = default;
+
+        T[] array;
+        int tailIndex;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add(T element)
+        {
+            if (array == null)
+            {
+                array = new T[InitialCapacity];
+            }
+            else if (array.Length == tailIndex)
+            {
+                Array.Resize(ref array, tailIndex * 2);
+            }
+
+            array[tailIndex] = element;
+            tailIndex++;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void RemoveAtSwapback(int index)
+        {
+            Error.IsNull(array);
+            CheckIndex(index);
+
+            array[index] = array[tailIndex - 1];
+            array[tailIndex - 1] = default;
+            tailIndex--;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear(bool removeArray = false)
+        {
+            if (array == null) return;
+
+            array.AsSpan().Clear();
+            tailIndex = 0;
+            if (removeArray) array = null;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void EnsureCapacity(int capacity)
+        {
+            if (array == null)
+            {
+                array = new T[InitialCapacity];
+            }
+
+            while (array.Length < capacity)
+            {
+                Array.Resize(ref array, array.Length * 2);
+            }
+        }
+
+        public readonly T this[int index]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => array[index];
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set => array[index] = value;
+        }
+
+        public readonly int Length
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => tailIndex;
+        }
+
+        public readonly Span<T> AsSpan() => array == null ? Span<T>.Empty : array.AsSpan(0, tailIndex);
+        public readonly T[] AsArray() => array;
+
+        readonly void CheckIndex(int index)
+        {
+            if (index < 0 || index > tailIndex) throw new IndexOutOfRangeException();
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/FastListCore.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3404502f0ea4c459fb981efa92cee882
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/ILinkedPoolNode.cs

@@ -0,0 +1,11 @@
+namespace LitMotion.Collections
+{
+    /// <summary>
+    /// An object pool node consisting of a linked list
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ILinkedPoolNode<T> where T : class
+    {
+        ref T NextNode { get; }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/ILinkedPoolNode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9ffad27e8ecbe4cfbacfcb4a5d3d2e4e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/LinkedPool.cs

@@ -0,0 +1,66 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace LitMotion.Collections
+{
+    /// <summary>
+    /// Thread-safe linked list object pool
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [StructLayout(LayoutKind.Auto)]
+    public struct LinkedPool<T> where T : class, ILinkedPoolNode<T>
+    {
+        static readonly int MaxPoolSize = int.MaxValue;
+
+        int gate;
+        int size;
+        T root;
+
+        public readonly int Size => size;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryPop(out T result)
+        {
+            if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+            {
+                var v = root;
+                if (v != null)
+                {
+                    ref var nextNode = ref v.NextNode;
+                    root = nextNode;
+                    nextNode = null;
+                    size--;
+                    result = v;
+                    Volatile.Write(ref gate, 0);
+                    return true;
+                }
+
+                Volatile.Write(ref gate, 0);
+            }
+            result = default;
+            return false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryPush(T item)
+        {
+            if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+            {
+                if (size < MaxPoolSize)
+                {
+                    item.NextNode = root;
+                    root = item;
+                    size++;
+                    Volatile.Write(ref gate, 0);
+                    return true;
+                }
+                else
+                {
+                    Volatile.Write(ref gate, 0);
+                }
+            }
+            return false;
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/LinkedPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 81cf813915d5c42fe871f942c2085cf0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/NativeAnimationCurve.cs

@@ -0,0 +1,69 @@
+using System;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;
+
+// TODO: avoid animationCurve.keys allocation
+
+namespace LitMotion.Collections
+{
+    public unsafe struct NativeAnimationCurve : IDisposable
+    {
+        NativeList<Keyframe> keys;
+        WrapMode preWrapMode;
+        WrapMode postWrapMode;
+
+        public NativeAnimationCurve(AllocatorManager.AllocatorHandle allocator)
+        {
+            keys = new NativeList<Keyframe>(0, allocator);
+            preWrapMode = default;
+            postWrapMode = default;
+        }
+
+        public NativeAnimationCurve(AnimationCurve animationCurve, AllocatorManager.AllocatorHandle allocator)
+        {
+            var l = animationCurve.length;
+            keys = new NativeList<Keyframe>(l, allocator);
+            keys.Resize(l, NativeArrayOptions.UninitializedMemory);
+            fixed (Keyframe* src = &animationCurve.keys[0])
+            {
+                UnsafeUtility.MemCpy(keys.GetUnsafePtr(), src, l * sizeof(Keyframe));
+            }
+            keys.Sort(default(KeyframeComparer));
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void CopyFrom(AnimationCurve animationCurve)
+        {
+            var l = animationCurve.length;
+            keys.Resize(l, NativeArrayOptions.UninitializedMemory);
+            fixed (Keyframe* src = &animationCurve.keys[0])
+            {
+                UnsafeUtility.MemCpy(keys.GetUnsafePtr(), src, l * sizeof(Keyframe));
+            }
+            keys.Sort(default(KeyframeComparer));
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void CopyFrom(in NativeAnimationCurve animationCurve)
+        {
+            keys.CopyFrom(animationCurve.keys);
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void Dispose()
+        {
+            keys.Dispose();
+        }
+
+        public readonly bool IsCreated => keys.IsCreated;
+
+        public float Evaluate(float time)
+        {
+            return NativeAnimationCurveHelper.Evaluate((Keyframe*)keys.GetUnsafePtr(), keys.Length, preWrapMode, postWrapMode, time);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/NativeAnimationCurve.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4f605bdaf1b414672aa2d0ce42588df7

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/NativeAnimationCurveHelper.cs

@@ -0,0 +1,224 @@
+using System.Collections.Generic;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace LitMotion.Collections
+{
+    internal readonly struct KeyframeComparer : IComparer<Keyframe>
+    {
+        public readonly int Compare(Keyframe keyframe1, Keyframe keyframe2) => keyframe1.time.CompareTo(keyframe2.time);
+    }
+
+    [BurstCompile]
+    internal unsafe static class NativeAnimationCurveHelper
+    {
+        static readonly float4x4 curveMatrix = new
+        (
+            1, 0, 0, 0,
+            -3, 3, 0, 0,
+            3, -6, 3, 0,
+            -1, 3, -3, 1
+        );
+
+        static readonly float3x3 curveMatrixPrime = new
+        (
+            1, 0, 0,
+            -2, 2, 0,
+            1, -2, 1
+        );
+
+        [BurstCompile]
+        public static float Evaluate(Keyframe* ptr, int length, WrapMode preWrapMode, WrapMode postWrapMode, float time)
+        {
+            time = WrapTime(ptr, length, preWrapMode, postWrapMode, time);
+            Keyframe keyframe = default;
+            keyframe.time = time;
+            int index = GetInsertionIndexForSortedArray(ptr, length, ref keyframe);
+            if (index == 0)
+            {
+                index++;
+            }
+            else if (index == length)
+            {
+                index = length - 1;
+            }
+            keyframe = ptr[index - 1];
+            Keyframe nextKeyframe = ptr[index];
+            return Evaluate(time, ref keyframe, ref nextKeyframe);
+        }
+
+        static int GetInsertionIndexForSortedArray(Keyframe* ptr, int length, ref Keyframe keyframe)
+        {
+            var list = new UnsafeList<Keyframe>(ptr, length);
+            var index = list.BinarySearch(keyframe, default(KeyframeComparer));
+            if (index < 0) index = ~index;
+            return index;
+        }
+
+        static float WrapTime(Keyframe* ptr, int length, WrapMode preWrapMode, WrapMode postWrapMode, float time)
+        {
+            float lastKeyTime = ptr[length - 1].time;
+            if (time < 0f)
+            {
+                switch (preWrapMode)
+                {
+                    case WrapMode.Default:
+                    case WrapMode.ClampForever:
+                    case WrapMode.Once:
+                        time = 0f;
+                        break;
+                    case WrapMode.Loop:
+                        time = time % lastKeyTime - ptr[0].time;
+                        break;
+                    case WrapMode.PingPong:
+                        time = Mathf.PingPong(time, lastKeyTime - ptr[0].time);
+                        break;
+                }
+            }
+            else if (time > lastKeyTime)
+            {
+                switch (postWrapMode)
+                {
+                    case WrapMode.Default:
+                    case WrapMode.ClampForever:
+                        time = lastKeyTime;
+                        break;
+                    case WrapMode.Once:
+                        time = 0f;
+                        break;
+                    case WrapMode.Loop:
+                        time = time % lastKeyTime - ptr[0].time;
+                        break;
+                    case WrapMode.PingPong:
+                        time = Mathf.PingPong(time, lastKeyTime - ptr[0].time);
+                        break;
+                }
+            }
+            return time;
+        }
+
+        static float Evaluate(float time, ref Keyframe keyframe, ref Keyframe nextKeyframe)
+        {
+            if (!math.isfinite(keyframe.outTangent) || !math.isfinite(nextKeyframe.inTangent))
+            {
+                return keyframe.value;
+            }
+            float timeDiff = nextKeyframe.time - keyframe.time;
+            float t = (time - keyframe.time) / timeDiff;
+            float outWeight = (int)keyframe.weightedMode >= (int)WeightedMode.Out ? keyframe.outWeight : 1f / 3f;
+            float inWeight = (int)nextKeyframe.weightedMode >= (int)WeightedMode.In ? nextKeyframe.inWeight : 1f / 3f;
+            float tBottom = 0, tTop = 1;
+            float diff = float.MaxValue;
+
+            float4 xCoords = new(keyframe.time, keyframe.time + outWeight * timeDiff, nextKeyframe.time - inWeight * timeDiff, nextKeyframe.time);
+            float4 curveXCoords = math.mul(curveMatrix, xCoords);
+            GetTWithNewtonMethod(time, in xCoords, in curveXCoords, ref t, ref tBottom, ref tTop, ref diff);
+            GetTWithBisectionMethod(time, in curveXCoords, ref t, ref tBottom, ref tTop, ref diff);
+
+            float4 yCoords = new(keyframe.value, keyframe.value + outWeight * keyframe.outTangent * timeDiff, nextKeyframe.value - inWeight * nextKeyframe.inTangent * timeDiff, nextKeyframe.value);
+            float4 curveYCoords = math.mul(curveMatrix, yCoords);
+            return CubicBezier(in curveYCoords, t);
+        }
+
+        static float CubicBezier(in float4 curveMatrix, float t)
+        {
+            float tt = t * t;
+            float4 powerSeries = new(1, t, tt, tt * t);
+            return math.dot(powerSeries, curveMatrix);
+        }
+
+        static float CubicBezier(in float3 curveMatrix, float t)
+        {
+            float3 powerSeries = new(1, t, t * t);
+            return math.dot(powerSeries, curveMatrix);
+        }
+
+        static float DeCasteljauBezier(int degree, float4 coords, float t)
+        {
+            float one_t = 1 - t;
+            for (int k = 1; k <= degree; k++)
+            {
+                for (int i = 0; i <= (degree - k); i++)
+                {
+                    coords[i] = one_t * coords[i] + t * coords[i + 1];
+                }
+            }
+            return coords[0];
+        }
+
+        static void GetTWithBisectionMethod(float time, in float4 curveXCoords, ref float t, ref float tBottom, ref float tTop, ref float diff)
+        {
+            const float accuracy = 0.0000001f;
+            const int maxIterationCount = 20;
+            int iterationCount = 0;
+            while (diff > accuracy && iterationCount < maxIterationCount)
+            {
+                iterationCount++;
+                t = (tTop + tBottom) * 0.5f;
+                float x = CubicBezier(in curveXCoords, t);
+                diff = math.abs(x - time);
+                UpdateTLimits(x, time, t, ref tBottom, ref tTop);
+            }
+        }
+
+        static void GetTWithNewtonMethod(float time, in float4 xCoords, in float4 curveXCoords, ref float t, ref float tBottom, ref float tTop, ref float diff)
+        {
+            const float accuracy = 0.0000001f;
+            const int maxIterationCount = 20;
+            int iterationCount = 0;
+
+            float4 primeCoords = default;
+            for (int i = 0; i < 3; i++)
+            {
+                primeCoords[i] = (xCoords[i + 1] - xCoords[i]) * 3;
+            }
+            float4 primePrimeCoords = default;
+            for (int i = 0; i < 2; i++)
+            {
+                primePrimeCoords[i] = (primeCoords[i + 1] - primeCoords[i]) * 2;
+            }
+
+            float3 curvePrimeCoords = math.mul(curveMatrixPrime, primeCoords.xyz);
+            while (diff > accuracy && iterationCount < maxIterationCount)
+            {
+                iterationCount++;
+                float x;
+                float newT = UseNewtonMethod(curveXCoords, time, t, curvePrimeCoords, primePrimeCoords, out x);
+                float newDiff = math.abs(x - time);
+                if (newT < 0 || newT > 1 || newDiff > diff)
+                {
+                    break;
+                }
+                diff = newDiff;
+                UpdateTLimits(x, time, t, ref tBottom, ref tTop);
+                t = newT;
+            }
+        }
+
+        static float UseNewtonMethod(float4 curveCoords, float coord, float t, float3 curvePrimeCoords, float4 primePrimeCoords, out float coordAtT)
+        {
+            coordAtT = CubicBezier(in curveCoords, t);
+            float coordPrimeAtT = CubicBezier(in curvePrimeCoords, t);
+            float coordPrimePrimeAtT = DeCasteljauBezier(1, primePrimeCoords, t);
+            float coordAtTMinusCoord = coordAtT - coord;
+            float fAtT = coordAtTMinusCoord * coordPrimeAtT;
+            float fPrimeAtT = coordAtTMinusCoord * coordPrimePrimeAtT + coordPrimeAtT * coordPrimeAtT;
+            return t - (fAtT / fPrimeAtT);
+        }
+
+        static void UpdateTLimits(float x, float time, float t, ref float tBottom, ref float tTop)
+        {
+            if (x > time)
+            {
+                tTop = math.clamp(t, tBottom, tTop);
+            }
+            else
+            {
+                tBottom = math.clamp(t, tBottom, tTop);
+            }
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/NativeAnimationCurveHelper.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fdd77e3d0215945c9b2e07acf9ed684d

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/UnsafeAnimationCurve.cs

@@ -0,0 +1,69 @@
+using System;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;
+
+// TODO: avoid animationCurve.keys allocation
+
+namespace LitMotion.Collections
+{
+    public unsafe struct UnsafeAnimationCurve : IDisposable
+    {
+        internal UnsafeList<Keyframe> keys;
+        internal WrapMode preWrapMode;
+        internal WrapMode postWrapMode;
+
+        public UnsafeAnimationCurve(AllocatorManager.AllocatorHandle allocator)
+        {
+            keys = new UnsafeList<Keyframe>(0, allocator);
+            preWrapMode = default;
+            postWrapMode = default;
+        }
+
+        public UnsafeAnimationCurve(AnimationCurve animationCurve, AllocatorManager.AllocatorHandle allocator)
+        {
+            var l = animationCurve.length;
+            keys = new UnsafeList<Keyframe>(l, allocator);
+            keys.Resize(l, NativeArrayOptions.UninitializedMemory);
+            fixed (Keyframe* src = &animationCurve.keys[0])
+            {
+                UnsafeUtility.MemCpy(keys.Ptr, src, l * sizeof(Keyframe));
+            }
+            keys.Sort(default(KeyframeComparer));
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void CopyFrom(AnimationCurve animationCurve)
+        {
+            var l = animationCurve.length;
+            keys.Resize(l, NativeArrayOptions.UninitializedMemory);
+            fixed (Keyframe* src = &animationCurve.keys[0])
+            {
+                UnsafeUtility.MemCpy(keys.Ptr, src, l * sizeof(Keyframe));
+            }
+            keys.Sort(default(KeyframeComparer));
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void CopyFrom(in UnsafeAnimationCurve animationCurve)
+        {
+            keys.CopyFrom(animationCurve.keys);
+            preWrapMode = animationCurve.preWrapMode;
+            postWrapMode = animationCurve.postWrapMode;
+        }
+
+        public void Dispose()
+        {
+            keys.Dispose();
+        }
+
+        public readonly bool IsCreated => keys.IsCreated;
+
+        public float Evaluate(float time)
+        {
+            return NativeAnimationCurveHelper.Evaluate(keys.Ptr, keys.Length, preWrapMode, postWrapMode, time);
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Collections/UnsafeAnimationCurve.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 520ae485e184045e289624300aca9fae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/CompositeMotionHandle.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace LitMotion
+{
+    /// <summary>
+    /// A class that manages multiple motion handles at once.
+    /// </summary>
+    public sealed class CompositeMotionHandle : ICollection<MotionHandle>, IEnumerable<MotionHandle>
+    {
+        public CompositeMotionHandle()
+        {
+            handleList = new();
+        }
+
+        public CompositeMotionHandle(int capacity)
+        {
+            if (capacity < 0)
+            {
+                throw new ArgumentOutOfRangeException("capacity");
+            }
+            
+            handleList = new(capacity);
+        }
+
+        /// <summary>
+        /// Cancel all Motion handles and clear list.
+        /// </summary>
+        public void Cancel()
+        {
+            for (int i = 0; i < handleList.Count; i++)
+            {
+                var handle = handleList[i];
+                if (handle.IsActive()) handle.Cancel();
+            }
+            handleList.Clear();
+        }
+
+        /// <summary>
+        /// Complete all motion handles and clear list.
+        /// </summary>
+        public void Complete()
+        {
+            for (int i = 0; i < handleList.Count; i++)
+            {
+                var handle = handleList[i];
+                if (handle.IsActive()) handle.Complete();
+            }
+            handleList.Clear();
+        }
+
+        /// <summary>
+        /// Add motion handle.
+        /// </summary>
+        /// <param name="handle">Motion handle</param>
+        public void Add(MotionHandle handle)
+        {
+            handleList.Add(handle);
+        }
+
+        public List<MotionHandle>.Enumerator GetEnumerator()
+        {
+            return handleList.GetEnumerator();
+        }
+
+        IEnumerator<MotionHandle> IEnumerable<MotionHandle>.GetEnumerator()
+        {
+            return handleList.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return handleList.GetEnumerator();
+        }
+
+        public void Clear()
+        {
+            handleList.Clear();
+        }
+
+        public bool Contains(MotionHandle item)
+        {
+            return handleList.Contains(item);
+        }
+
+        public void CopyTo(MotionHandle[] array, int arrayIndex)
+        {
+            handleList.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(MotionHandle item)
+        {
+            return handleList.Remove(item);
+        }
+
+        public int Count => handleList.Count;
+        public bool IsReadOnly => false;
+
+        readonly List<MotionHandle> handleList;
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/CompositeMotionHandle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a7cb20d338a74c2a91ad89af0e091b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/DelayType.cs

@@ -0,0 +1,17 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Specifies the behavior of WithDelay.
+    /// </summary>
+    public enum DelayType : byte
+    {
+        /// <summary>
+        /// Delay when starting playback
+        /// </summary>
+        FirstLoop = 0,
+        /// <summary>
+        /// Delay every loop
+        /// </summary>
+        EveryLoop = 1,
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/DelayType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ede4abfbaa71b475ab0e832d38c4495a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Ease.cs

@@ -0,0 +1,41 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Specifies the easing to apply to the animation.
+    /// </summary>
+    public enum Ease
+    {
+        Linear,
+        InSine,
+        OutSine,
+        InOutSine,
+        InQuad,
+        OutQuad,
+        InOutQuad,
+        InCubic,
+        OutCubic,
+        InOutCubic,
+        InQuart,
+        OutQuart,
+        InOutQuart,
+        InQuint,
+        OutQuint,
+        InOutQuint,
+        InExpo,
+        OutExpo,
+        InOutExpo,
+        InCirc,
+        OutCirc,
+        InOutCirc,
+        InElastic,
+        OutElastic,
+        InOutElastic,
+        InBack,
+        OutBack,
+        InOutBack,
+        InBounce,
+        OutBounce,
+        InOutBounce,
+        CustomAnimationCurve
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Ease.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3092f5a4722144848ba027834b1e89a8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/EaseUtility.cs

@@ -0,0 +1,222 @@
+using Unity.Burst;
+using static Unity.Mathematics.math;
+
+namespace LitMotion
+{
+    /// <summary>
+    /// Utility class that provides calculation of easing functions.
+    /// </summary>
+    [BurstCompile]
+    public static class EaseUtility
+    {
+        [BurstCompile]
+        public static float Evaluate(float t, Ease ease)
+        {
+            return ease switch
+            {
+                Ease.InSine => InSine(t),
+                Ease.OutSine => OutSine(t),
+                Ease.InOutSine => InOutSine(t),
+                Ease.InQuad => InQuad(t),
+                Ease.OutQuad => OutQuad(t),
+                Ease.InOutQuad => InOutQuad(t),
+                Ease.InCubic => InCubic(t),
+                Ease.OutCubic => OutCubic(t),
+                Ease.InOutCubic => InOutCubic(t),
+                Ease.InQuart => InQuart(t),
+                Ease.OutQuart => OutQuart(t),
+                Ease.InOutQuart => InOutQuart(t),
+                Ease.InQuint => InQuint(t),
+                Ease.OutQuint => OutQuint(t),
+                Ease.InOutQuint => InOutQuint(t),
+                Ease.InExpo => InExpo(t),
+                Ease.OutExpo => OutExpo(t),
+                Ease.InOutExpo => InOutExpo(t),
+                Ease.InCirc => InCirc(t),
+                Ease.OutCirc => OutCirc(t),
+                Ease.InOutCirc => InOutCirc(t),
+                Ease.InElastic => InElastic(t),
+                Ease.OutElastic => OutElastic(t),
+                Ease.InOutElastic => InOutElastic(t),
+                Ease.InBack => InBack(t),
+                Ease.OutBack => OutBack(t),
+                Ease.InOutBack => InOutBack(t),
+                Ease.InBounce => InBounce(t),
+                Ease.OutBounce => OutBounce(t),
+                Ease.InOutBounce => InOutBounce(t),
+                _ => t,
+            };
+        }
+
+        [BurstCompile]
+        public static float Linear(float x) => x;
+
+        [BurstCompile]
+        public static float InSine(float x) => 1 - cos(x * PI / 2);
+
+        [BurstCompile]
+        public static float OutSine(float x) => sin(x * PI / 2);
+
+        [BurstCompile]
+        public static float InOutSine(float x) => -(cos(PI * x) - 1) / 2;
+
+        [BurstCompile]
+        public static float InQuad(float x) => x * x;
+
+        [BurstCompile]
+        public static float OutQuad(float x) => 1 - (1 - x) * (1 - x);
+
+        [BurstCompile]
+        public static float InOutQuad(float x) => x < 0.5f ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2;
+
+        [BurstCompile]
+        public static float InCubic(float x) => x * x * x;
+
+        [BurstCompile]
+        public static float OutCubic(float x) => 1 - pow(1 - x, 3);
+
+        [BurstCompile]
+        public static float InOutCubic(float x) => x < 0.5f ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
+
+        [BurstCompile]
+        public static float InQuart(float x) => x * x * x * x;
+
+        [BurstCompile]
+        public static float OutQuart(float x) => 1 - pow(1 - x, 4);
+
+        [BurstCompile]
+        public static float InOutQuart(float x) => x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2;
+
+        [BurstCompile]
+        public static float InQuint(float x) => x * x * x * x * x;
+
+        [BurstCompile]
+        public static float OutQuint(float x) => 1 - pow(1 - x, 5);
+
+        [BurstCompile]
+        public static float InOutQuint(float x) => x < 0.5f ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2;
+
+        [BurstCompile]
+        public static float InExpo(float x) => x == 0 ? 0 : pow(2, 10 * x - 10);
+
+        [BurstCompile]
+        public static float OutExpo(float x) => x == 1 ? 1 : 1 - pow(2, -10 * x);
+
+        [BurstCompile]
+        public static float InOutExpo(float x)
+        {
+            return x == 0 ? 0 :
+                x == 1 ? 1 :
+                x < 0.5f ? pow(2, 20 * x - 10) / 2 :
+                (2 - pow(2, -20 * x + 10)) / 2;
+        }
+
+        [BurstCompile]
+        public static float InCirc(float x) => 1 - sqrt(1 - pow(x, 2));
+
+        [BurstCompile]
+        public static float OutCirc(float x) => sqrt(1 - pow(x - 1, 2));
+
+        [BurstCompile]
+        public static float InOutCirc(float x)
+        {
+            return x < 0.5 ?
+                (1 - sqrt(1 - pow(2 * x, 2))) / 2 :
+                (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
+        }
+
+        [BurstCompile]
+        public static float InBack(float x)
+        {
+            const float c1 = 1.70158f;
+            const float c3 = c1 + 1;
+            return c3 * x * x * x - c1 * x * x;
+        }
+
+        [BurstCompile]
+        public static float OutBack(float x)
+        {
+            const float c1 = 1.70158f;
+            const float c3 = c1 + 1;
+            return 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2);
+        }
+
+        [BurstCompile]
+        public static float InOutBack(float x)
+        {
+            const float c1 = 1.70158f;
+            const float c2 = c1 * 1.525f;
+
+            return x < 0.5f
+                ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2
+                : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+        }
+
+        [BurstCompile]
+        public static float InElastic(float x)
+        {
+            const float c4 = 2 * PI / 3;
+
+            return x == 0 ? 0 :
+                x == 1 ? 1 :
+                -pow(2, 10 * x - 10) * sin((x * 10 - 10.75f) * c4);
+        }
+
+        [BurstCompile]
+        public static float OutElastic(float x)
+        {
+            const float c4 = 2 * PI / 3;
+
+            return x == 0 ? 0 :
+                x == 1 ? 1 :
+                pow(2, -10 * x) * sin((x * 10 - 0.75f) * c4) + 1;
+        }
+
+        [BurstCompile]
+        public static float InOutElastic(float x)
+        {
+            const float c5 = 2 * PI / 4.5f;
+
+            return x == 0 ? 0 :
+                x == 1 ? 1 :
+                x < 0.5f ?
+                -(pow(2, 20 * x - 10) * sin((20 * x - 11.125f) * c5)) / 2 :
+                pow(2, -20 * x + 10) * sin((20 * x - 11.125f) * c5) / 2 + 1;
+        }
+
+        [BurstCompile]
+        public static float InBounce(float x) => 1 - OutBounce(1 - x);
+
+        [BurstCompile]
+        public static float OutBounce(float x)
+        {
+            const float n1 = 7.5625f;
+            const float d1 = 2.75f;
+            float t = x;
+
+            if (t < 1 / d1)
+            {
+                return n1 * t * t;
+            }
+            else if (t < 2 / d1)
+            {
+                return n1 * (t -= 1.5f / d1) * t + 0.75f;
+            }
+            else if (t < 2.5 / d1)
+            {
+                return n1 * (t -= 2.25f / d1) * t + 0.9375f;
+            }
+            else
+            {
+                return n1 * (t -= 2.625f / d1) * t + 0.984375f;
+            }
+        }
+        [BurstCompile]
+        public static float InOutBounce(float x)
+        {
+            return x < 0.5f ?
+                (1 - OutBounce(1 - 2 * x)) / 2 :
+                (1 + OutBounce(2 * x - 1)) / 2;
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/EaseUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 65109fdf2e5ab4528ae4c46a553182c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9fb4a7a7fdcb84fd8a6ea34fcc488852
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e14e60b4451984f5b8f0834195b96038
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionAudioExtensions.cs

@@ -0,0 +1,70 @@
+#if LITMOTION_SUPPORT_UNITY_AUDIO
+using UnityEngine;
+using UnityEngine.Audio;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for AudioSource and AudioMixer.
+    /// </summary>
+    public static class LitMotionAudioExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to AudioSource.volume
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVolume<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, AudioSource audioSource)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(audioSource);
+            return builder.BindWithState(audioSource, static (x, target) =>
+            {
+                target.volume = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to AudioSource.pitch
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPitch<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, AudioSource audioSource)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(audioSource);
+            return builder.BindWithState(audioSource, static (x, target) =>
+            {
+                target.pitch = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to AudioMixer exposed parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAudioMixerFloat<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, AudioMixer audioMixer, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(audioMixer);
+            return builder.BindWithState(audioMixer, name, static (x, target, n) =>
+            {
+                target.SetFloat(n, x);
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionAudioExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 55c55793a19b449fb800ac1f9d9a79d7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionMaterialExtensions.cs

@@ -0,0 +1,124 @@
+using UnityEngine;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for Material.
+    /// </summary>
+    public static class LitMotionMaterialExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialFloat<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Material material, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, name, static (x, m, n) =>
+            {
+                m.SetFloat(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialFloat<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Material material, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, (x, m) =>
+            {
+                m.SetFloat(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialInt<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, Material material, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, name, static (x, m, n) =>
+            {
+                m.SetInteger(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialInt<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, Material material, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, (x, m) =>
+            {
+                m.SetInteger(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, Material material, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, name, static (x, m, n) =>
+            {
+                m.SetColor(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to a material property.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaterialColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, Material material, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(material);
+            return builder.BindWithState(material, (x, m) =>
+            {
+                m.SetColor(nameID, x);
+            });
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionMaterialExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f8c744a691a44dc287cca2f327bd957
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionSpriteRendererExtensions.cs

@@ -0,0 +1,113 @@
+using UnityEngine;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for SpriteRenderer.
+    /// </summary>
+    public static class LitMotionSpriteRendererExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to SpriteRenderer.color
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, SpriteRenderer spriteRenderer)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(spriteRenderer);
+            return builder.BindWithState(spriteRenderer, static (x, m) =>
+            {
+                m.color = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to SpriteRenderer.color.r
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, SpriteRenderer spriteRenderer)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(spriteRenderer);
+            return builder.BindWithState(spriteRenderer, static (x, m) =>
+            {
+                var c = m.color;
+                c.r = x;
+                m.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to SpriteRenderer.color.g
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, SpriteRenderer spriteRenderer)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(spriteRenderer);
+            return builder.BindWithState(spriteRenderer, static (x, m) =>
+            {
+                var c = m.color;
+                c.g = x;
+                m.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to SpriteRenderer.color.b
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, SpriteRenderer spriteRenderer)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(spriteRenderer);
+            return builder.BindWithState(spriteRenderer, static (x, m) =>
+            {
+                var c = m.color;
+                c.b = x;
+                m.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to SpriteRenderer.color.a
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, SpriteRenderer spriteRenderer)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(spriteRenderer);
+            return builder.BindWithState(spriteRenderer, static (x, m) =>
+            {
+                var c = m.color;
+                c.a = x;
+                m.color = c;
+            });
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionSpriteRendererExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 063586bfc0e4845ed97b637edc3d2ab4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionTransformExtensions.cs

@@ -0,0 +1,789 @@
+using UnityEngine;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for Transform.
+    /// </summary>
+    public static class LitMotionTransformExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPosition<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.position = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.x = x;
+                t.position = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.y = x;
+                t.position = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.z = x;
+                t.position = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.xy
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionXY<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.x = x.x;
+                p.y = x.y;
+                t.position = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.xz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionXZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.x = x.x;
+                p.z = x.y;
+                t.position = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.position.yz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPositionYZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.position;
+                p.y = x.x;
+                p.z = x.y;
+                t.position = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPosition<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.localPosition = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.x = x;
+                t.localPosition = p;
+            });
+        }
+
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.y = x;
+                t.localPosition = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.z = x;
+                t.localPosition = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.xy
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionXY<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.x = x.x;
+                p.y = x.y;
+                t.localPosition = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.xz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionXZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.x = x.x;
+                p.z = x.y;
+                t.localPosition = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localPosition.yz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalPositionYZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localPosition;
+                p.y = x.x;
+                p.z = x.y;
+                t.localPosition = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.rotation
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToRotation<TOptions, TAdapter>(this MotionBuilder<Quaternion, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Quaternion, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.rotation = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localRotation
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalRotation<TOptions, TAdapter>(this MotionBuilder<Quaternion, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Quaternion, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.localRotation = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAngles<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.eulerAngles = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.x = x;
+                t.eulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.y = x;
+                t.eulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.z = x;
+                t.eulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.xy
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesXY<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.x = x.x;
+                p.y = x.y;
+                t.eulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.xz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesXZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.x = x.x;
+                p.z = x.y;
+                t.eulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.eulerAngles.yz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToEulerAnglesYZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.eulerAngles;
+                p.y = x.x;
+                p.z = x.y;
+                t.eulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAngles<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.localEulerAngles = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.x = x;
+                t.localEulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.y = x;
+                t.localEulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.z = x;
+                t.localEulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.xy
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesXY<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.x = x.x;
+                p.y = x.y;
+                t.localEulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.xz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesXZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.x = x.x;
+                p.z = x.y;
+                t.localEulerAngles = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localEulerAngles.yz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalEulerAnglesYZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localEulerAngles;
+                p.y = x.x;
+                p.z = x.y;
+                t.localEulerAngles = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScale<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                t.localScale = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.x = x;
+                t.localScale = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.y = x;
+                t.localScale = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.z = x;
+                t.localScale = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.xy
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleXY<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.x = x.x;
+                p.y = x.y;
+                t.localScale = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.xz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleXZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.x = x.x;
+                p.z = x.y;
+                t.localScale = p;
+            });
+        }
+        
+        /// <summary>
+        /// Create a motion data and bind it to Transform.localScale.yz
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToLocalScaleYZ<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, Transform transform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(transform);
+            return builder.BindWithState(transform, static (x, t) =>
+            {
+                var p = t.localScale;
+                p.y = x.x;
+                p.z = x.y;
+                t.localScale = p;
+            });
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/General/LitMotionTransformExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 23258fa7aa632462f86ae4c87dfcddb5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/LitMotion.Extensions.asmdef

@@ -0,0 +1,55 @@
+{
+    "name": "LitMotion.Extensions",
+    "rootNamespace": "LitMotion.Extensions",
+    "references": [
+        "GUID:3b570a5146f9d4f0fa107ed4559471a3",
+        "GUID:6055be8ebefd69e48b49212b09b47b2f",
+        "GUID:e0cd26848372d4e5c891c569017e11f1",
+        "GUID:33661e06c33d31b4c9223810bf503247"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.textmeshpro",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_TMP"
+        },
+        {
+            "name": "com.unity.ugui",
+            "expression": "2.0.0",
+            "define": "LITMOTION_SUPPORT_TMP"
+        },
+        {
+            "name": "com.unity.visualeffectgraph",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_VFX_GRAPH"
+        },
+        {
+            "name": "com.cysharp.zstring",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_ZSTRING"
+        },
+        {
+            "name": "com.unity.modules.uielements",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_UIELEMENTS"
+        },
+        {
+            "name": "com.unity.ugui",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_UGUI"
+        },
+        {
+            "name": "com.unity.modules.audio",
+            "expression": "",
+            "define": "LITMOTION_SUPPORT_UNITY_AUDIO"
+        }
+    ],
+    "noEngineReferences": false
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/LitMotion.Extensions.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3aa1866a824b5472da50fe142777d95f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/TextMeshPro.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 879a1a6ba1d4543f1820e8523676c63e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/TextMeshPro/LitMotionTextMeshProExtensions.cs

@@ -0,0 +1,971 @@
+#if LITMOTION_SUPPORT_TMP
+using System.Buffers;
+using UnityEngine;
+using Unity.Collections;
+using TMPro;
+#if LITMOTION_SUPPORT_ZSTRING
+using Cysharp.Text;
+#endif
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for TMP_Text
+    /// </summary>
+    public static class LitMotionTextMeshProExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.fontSize
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToFontSize<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.fontSize = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.maxVisibleCharacters
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaxVisibleCharacters<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.maxVisibleCharacters = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.maxVisibleLines
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaxVisibleLines<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.maxVisibleLines = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.maxVisibleWords
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToMaxVisibleWords<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.maxVisibleWords = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.color
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.color = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.color.r
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var c = target.color;
+                c.r = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.color.g
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var c = target.color;
+                c.g = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.color.b
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var c = target.color;
+                c.b = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.color.a
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var c = target.color;
+                c.a = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString32Bytes, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString32Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var enumerator = x.GetEnumerator();
+                var length = 0;
+                var buffer = ArrayPool<char>.Shared.Rent(64);
+                fixed (char* c = buffer)
+                {
+                    Unicode.Utf8ToUtf16(x.GetUnsafePtr(), x.Length, c, out length, x.Length * 2);
+                }
+                target.SetText(buffer, 0, length);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString64Bytes, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString64Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var enumerator = x.GetEnumerator();
+                var length = 0;
+                var buffer = ArrayPool<char>.Shared.Rent(128);
+                fixed (char* c = buffer)
+                {
+                    Unicode.Utf8ToUtf16(x.GetUnsafePtr(), x.Length, c, out length, x.Length * 2);
+                }
+                target.SetText(buffer, 0, length);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString128Bytes, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString128Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var enumerator = x.GetEnumerator();
+                var length = 0;
+                var buffer = ArrayPool<char>.Shared.Rent(256);
+                fixed (char* c = buffer)
+                {
+                    Unicode.Utf8ToUtf16(x.GetUnsafePtr(), x.Length, c, out length, x.Length * 2);
+                }
+                target.SetText(buffer, 0, length);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString512Bytes, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString512Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var enumerator = x.GetEnumerator();
+                var length = 0;
+                var buffer = ArrayPool<char>.Shared.Rent(1024);
+                fixed (char* c = buffer)
+                {
+                    Unicode.Utf8ToUtf16(x.GetUnsafePtr(), x.Length, c, out length, x.Length * 2);
+                }
+                target.SetText(buffer, 0, length);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString4096Bytes, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString4096Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                var enumerator = x.GetEnumerator();
+                var length = 0;
+                var buffer = ArrayPool<char>.Shared.Rent(8192);
+                fixed (char* c = buffer)
+                {
+                    Unicode.Utf8ToUtf16(x.GetUnsafePtr(), x.Length, c, out length, x.Length * 2);
+                }
+                target.SetText(buffer, 0, length);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+
+                var buffer = ArrayPool<char>.Shared.Rent(128);
+                var bufferOffset = 0;
+                Utf16StringHelper.WriteInt32(ref buffer, ref bufferOffset, x);
+                target.SetText(buffer, 0, bufferOffset);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TMP_Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.SetTextFormat(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+
+                var buffer = ArrayPool<char>.Shared.Rent(128);
+                var bufferOffset = 0;
+                Utf16StringHelper.WriteInt64(ref buffer, ref bufferOffset, x);
+                target.SetText(buffer, 0, bufferOffset);
+                ArrayPool<char>.Shared.Return(buffer);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, TMP_Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.SetTextFormat(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <remarks>
+        /// Note: This extension method uses TMP_Text.SetText() to achieve zero allocation, so it is recommended to use this method when binding to text.
+        /// </remarks>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            const string format = "{0}";
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.SetTextFormat(format, x);
+#else
+                target.SetText(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TMP_Text.text.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public unsafe static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.SetTextFormat(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character color.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].color = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character color.r.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].color.r = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character color.g.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].color.g = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character color.b.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].color.b = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character color.a.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].color.a = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character position.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharPosition<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].position = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character position.x.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharPositionX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].position.x = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character position.y.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharPositionY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].position.y = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character position.z.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharPositionZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].position.z = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character rotation.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharRotation<TOptions, TAdapter>(this MotionBuilder<Quaternion, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Quaternion, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].rotation = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character rotation (using euler angles).
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharEulerAngles<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].rotation = Quaternion.Euler(x);
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character rotation (using euler angles).
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharEulerAnglesX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                var eulerAngles = animator.charInfoArray[charIndex].rotation.eulerAngles;
+                eulerAngles.x = x;
+                animator.charInfoArray[charIndex].rotation = Quaternion.Euler(eulerAngles);
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character rotation (using euler angles).
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharEulerAnglesY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                var eulerAngles = animator.charInfoArray[charIndex].rotation.eulerAngles;
+                eulerAngles.y = x;
+                animator.charInfoArray[charIndex].rotation = Quaternion.Euler(eulerAngles);
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character rotation (using euler angles).
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharEulerAnglesZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                var eulerAngles = animator.charInfoArray[charIndex].rotation.eulerAngles;
+                eulerAngles.z = x;
+                animator.charInfoArray[charIndex].rotation = Quaternion.Euler(eulerAngles);
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character scale.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharScale<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].scale = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character scale.x.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharScaleX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].scale.x = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character scale.y.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharScaleY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].scale.y = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+
+        /// <summary>
+        /// Create motion data and bind it to the character scale.z.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="text">Target TMP_Text</param>
+        /// <param name="charIndex">Target character index</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToTMPCharScaleZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TMP_Text text, int charIndex)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+
+            var animator = TextMeshProMotionAnimator.Get(text);
+            animator.EnsureCapacity(charIndex + 1);
+            var handle = builder.BindWithState(animator, (x, target) =>
+            {
+                animator.charInfoArray[charIndex].scale.z = x;
+            });
+            animator.motionHandleList.Add(handle);
+
+            return handle;
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/TextMeshPro/LitMotionTextMeshProExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 65abae1efd6394dd69fbef378d6b8988
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/TextMeshPro/TextMeshProMotionAnimator.cs

@@ -0,0 +1,314 @@
+#if LITMOTION_SUPPORT_TMP
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+using TMPro;
+using LitMotion.Collections;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace LitMotion.Extensions
+{
+    // TODO: optimization
+
+    /// <summary>
+    /// Wrapper class for animating individual characters in TextMeshPro.
+    /// </summary>
+    internal sealed class TextMeshProMotionAnimator
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
+        static void Init()
+        {
+#if UNITY_EDITOR
+            var domainReloadDisabled = EditorSettings.enterPlayModeOptionsEnabled && EditorSettings.enterPlayModeOptions.HasFlag(EnterPlayModeOptions.DisableDomainReload);
+            if (!domainReloadDisabled && initialized) return;
+#else
+            if (initialized) return;
+#endif
+            PlayerLoopHelper.OnUpdate += UpdateAnimators;
+            initialized = true;
+        }
+
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+        static void InitEditor()
+        {
+            EditorApplication.update += UpdateAnimatorsEditor;
+        }
+#endif
+
+        static bool initialized;
+        static TextMeshProMotionAnimator rootNode;
+
+        internal static TextMeshProMotionAnimator Get(TMP_Text text)
+        {
+            if (textToAnimator.TryGetValue(text, out var animator))
+            {
+                animator.RemoveCompletedMotions();
+                if (animator.motionHandleList.Length == 0) animator.Reset();
+                return animator;
+            }
+
+            // get or create animator
+            animator = rootNode ?? new();
+            rootNode = animator.nextNode;
+            animator.nextNode = null;
+
+            // set target
+            animator.target = text;
+            animator.Reset();
+
+            // add to array
+            if (tail == animators.Length)
+            {
+                Array.Resize(ref animators, tail * 2);
+            }
+            animators[tail] = animator;
+            tail++;
+
+            // add to dictionary
+            textToAnimator.Add(text, animator);
+
+            return animator;
+        }
+
+        internal static void Return(TextMeshProMotionAnimator animator)
+        {
+            animator.nextNode = rootNode;
+            rootNode = animator;
+
+            textToAnimator.Remove(animator.target);
+            animator.target = null;
+        }
+
+        static readonly Dictionary<TMP_Text, TextMeshProMotionAnimator> textToAnimator = new();
+        static TextMeshProMotionAnimator[] animators = new TextMeshProMotionAnimator[8];
+        static int tail;
+
+        static void UpdateAnimators()
+        {
+            var j = tail - 1;
+
+            for (int i = 0; i < animators.Length; i++)
+            {
+                var animator = animators[i];
+                if (animator != null)
+                {
+                    if (!animator.TryUpdate())
+                    {
+                        Return(animator);
+                        animators[i] = null;
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+
+                while (i < j)
+                {
+                    var fromTail = animators[j];
+                    if (fromTail != null)
+                    {
+                        if (!fromTail.TryUpdate())
+                        {
+                            Return(fromTail);
+                            animators[j] = null;
+                            j--;
+                            continue;
+                        }
+                        else
+                        {
+                            animators[i] = fromTail;
+                            animators[j] = null;
+                            j--;
+                            goto NEXT_LOOP;
+                        }
+                    }
+                    else
+                    {
+                        j--;
+                    }
+                }
+
+                tail = i;
+                break;
+
+            NEXT_LOOP:
+                continue;
+            }
+        }
+
+#if UNITY_EDITOR
+        static void UpdateAnimatorsEditor()
+        {
+            if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating)
+            {
+                return;
+            }
+            UpdateAnimators();
+        }
+#endif
+
+        internal struct CharInfo
+        {
+            public Vector3 position;
+            public Vector3 scale;
+            public Quaternion rotation;
+            public Color color;
+        }
+
+        public TextMeshProMotionAnimator()
+        {
+            charInfoArray = new CharInfo[32];
+            for (int i = 0; i < charInfoArray.Length; i++)
+            {
+                charInfoArray[i].color = Color.white;
+                charInfoArray[i].rotation = Quaternion.identity;
+                charInfoArray[i].scale = Vector3.one;
+                charInfoArray[i].position = Vector3.zero;
+            }
+        }
+
+        TMP_Text target;
+        internal CharInfo[] charInfoArray;
+        internal FastListCore<MotionHandle> motionHandleList;
+
+        TextMeshProMotionAnimator nextNode;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void EnsureCapacity(int length)
+        {
+            var prevLength = charInfoArray.Length;
+            if (length > prevLength)
+            {
+                Array.Resize(ref charInfoArray, length);
+
+                if (length > prevLength)
+                {
+                    for (int i = prevLength; i < length; i++)
+                    {
+                        charInfoArray[i].color = new(target.color.r, target.color.g, target.color.b, target.color.a);
+                        charInfoArray[i].rotation = Quaternion.identity;
+                        charInfoArray[i].scale = Vector3.one;
+                        charInfoArray[i].position = Vector3.zero;
+                    }
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Update()
+        {
+            TryUpdate();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetCharColor(int charIndex, Color color)
+        {
+            charInfoArray[charIndex].color = color;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetCharPosition(int charIndex, Vector3 position)
+        {
+            charInfoArray[charIndex].position = position;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetCharRotation(int charIndex, Quaternion rotation)
+        {
+            charInfoArray[charIndex].rotation = rotation;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetCharScale(int charIndex, Vector3 scale)
+        {
+            charInfoArray[charIndex].scale = scale;
+        }
+
+        public void Reset()
+        {
+            for (int i = 0; i < charInfoArray.Length; i++)
+            {
+                charInfoArray[i].color = new(target.color.r, target.color.g, target.color.b, target.color.a);
+                charInfoArray[i].rotation = Quaternion.identity;
+                charInfoArray[i].scale = Vector3.one;
+                charInfoArray[i].position = Vector3.zero;
+            }
+        }
+
+        void RemoveCompletedMotions()
+        {
+            for (int i = 0; i < motionHandleList.Length; i++)
+            {
+                if (!motionHandleList[i].IsActive())
+                {
+                    motionHandleList.RemoveAtSwapback(i);
+                    i--;
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        bool TryUpdate()
+        {
+            if (target == null) return false;
+
+            RemoveCompletedMotions();
+            if (motionHandleList.Length == 0) return false;
+
+            target.ForceMeshUpdate();
+
+            var textInfo = target.textInfo;
+            EnsureCapacity(textInfo.characterCount);
+
+            for (int i = 0; i < textInfo.characterCount; i++)
+            {
+                ref var charInfo = ref textInfo.characterInfo[i];
+                if (!charInfo.isVisible) continue;
+
+                var materialIndex = charInfo.materialReferenceIndex;
+                var vertexIndex = charInfo.vertexIndex;
+
+                ref var colors = ref textInfo.meshInfo[materialIndex].colors32;
+                ref var motionCharInfo = ref charInfoArray[i];
+
+                var charColor = motionCharInfo.color;
+                for (int n = 0; n < 4; n++)
+                {
+                    colors[vertexIndex + n] = charColor;
+                }
+
+                var verts = textInfo.meshInfo[materialIndex].vertices;
+                var center = (verts[vertexIndex] + verts[vertexIndex + 2]) * 0.5f;
+
+                var charRotation = motionCharInfo.rotation;
+                var charScale = motionCharInfo.scale;
+                var charOffset = motionCharInfo.position;
+                for (int n = 0; n < 4; n++)
+                {
+                    var vert = verts[vertexIndex + n];
+                    var dir = vert - center;
+                    verts[vertexIndex + n] = center +
+                        charRotation * new Vector3(dir.x * charScale.x, dir.y * charScale.y, dir.z * charScale.z) +
+                        charOffset;
+                }
+            }
+
+            for (int i = 0; i < textInfo.materialCount; i++)
+            {
+                if (textInfo.meshInfo[i].mesh == null) continue;
+                textInfo.meshInfo[i].mesh.colors32 = textInfo.meshInfo[i].colors32;
+                textInfo.meshInfo[i].mesh.vertices = textInfo.meshInfo[i].vertices;
+                target.UpdateGeometry(textInfo.meshInfo[i].mesh, i);
+            }
+
+            return true;
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/TextMeshPro/TextMeshProMotionAnimator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3fa78b38f856641ccb1749f37175dd20
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/UIToolkit.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 94dbd78df4c27476291d9a833963be12
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/UIToolkit/LitMotionUIToolkitExtensions.cs

@@ -0,0 +1,762 @@
+#if LITMOTION_SUPPORT_UIELEMENTS
+using Unity.Collections;
+using UnityEngine;
+using UnityEngine.UIElements;
+#if LITMOTION_SUPPORT_ZSTRING
+using Cysharp.Text;
+#endif
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for UIElements.
+    /// </summary>
+    public static class LitMotionUIToolkitExtensions
+    {
+        #region VisualElement
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.left
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleLeft<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.left = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.right
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleRight<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.right = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.top
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleTop<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.top = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.bottom
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBottom<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.bottom = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.width
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleWidth<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.width = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.height
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleHeight<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.height = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.color
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.color = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.color.r
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.color.value;
+                c.r = x;
+                target.style.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.color.g
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.color.value;
+                c.g = x;
+                target.style.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.color.b
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.color.value;
+                c.b = x;
+                target.style.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.color.a
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.color.value;
+                c.a = x;
+                target.style.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.backgroundColor
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBackgroundColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.backgroundColor = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.backgroundColor.r
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBackgroundColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.backgroundColor.value;
+                c.r = x;
+                target.style.backgroundColor = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.backgroundColor.g
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBackgroundColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.backgroundColor.value;
+                c.g = x;
+                target.style.backgroundColor = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.backgroundColor.b
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBackgroundColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.backgroundColor.value;
+                c.b = x;
+                target.style.backgroundColor = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.backgroundColor.a
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleBackgroundColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                var c = target.style.backgroundColor.value;
+                c.a = x;
+                target.style.backgroundColor = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.opacity
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleOpacity<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.opacity = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.fontSize
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleFontSize<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.fontSize = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.wordSpacing
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleWordSpacing<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.wordSpacing = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.translate
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleTranslate<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.translate = new Translate(x.x, x.y, x.z);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.translate
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleTranslate<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.translate = new Translate(x.x, x.y);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.rotate
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleRotate<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualElement visualElement, AngleUnit angleUnit = AngleUnit.Degree)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, (x, target) =>
+            {
+                target.style.rotate = new Rotate(new Angle(x, angleUnit));
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.scale
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleScale<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.scale = new Scale(x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.transformOrigin
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleTransformOrigin<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.transformOrigin = new TransformOrigin(x.x, x.y, x.z);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualElement.style.transformOrigin
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToStyleTransformOrigin<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, VisualElement visualElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(visualElement);
+            return builder.BindWithState(visualElement, static (x, target) =>
+            {
+                target.style.transformOrigin = new TransformOrigin(x.x, x.y);
+            });
+        }
+
+        #endregion
+
+        #region AbstractProgressBar
+
+        /// <summary>
+        /// Create a motion data and bind it to AbstractProgressBar.value
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToProgressBar<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, AbstractProgressBar progressBar)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(progressBar);
+            return builder.BindWithState(progressBar, static (x, target) =>
+            {
+                target.value = x;
+            });
+        }
+
+        #endregion
+
+        #region TextElement
+
+        /// <summary>
+        /// Create a motion data and bind it to TextElement.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString32Bytes, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString32Bytes, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TextElement.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString64Bytes, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString64Bytes, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TextElement.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString128Bytes, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString128Bytes, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TextElement.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString512Bytes, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString512Bytes, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to TextElement.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString4096Bytes, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString4096Bytes, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, TextElement textElement, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, format, static (x, target, f) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(f, x);
+#else
+                target.text = string.Format(f, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, TextElement textElement, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TextElement textElement)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, TextElement textElement, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(textElement);
+            return builder.BindWithState(textElement, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+        #endregion
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/UIToolkit/LitMotionUIToolkitExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1c22d85996abb4600b19bc1cd81e1eed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/VisualEffectGragh.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9176359351cda43119f67172e93af946
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/VisualEffectGragh/LitMotionVisualEffectExtensions.cs

@@ -0,0 +1,203 @@
+#if LITMOTION_SUPPORT_VFX_GRAPH
+using UnityEngine;
+using UnityEngine.VFX;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for VisualEffect.
+    /// </summary>
+    public static class LitMotionVisualEffectExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectFloat<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualEffect visualEffect, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, name, static (x, target, n) =>
+            {
+                target.SetFloat(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectFloat<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, VisualEffect visualEffect, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, (x, target) =>
+            {
+                target.SetFloat(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectInt<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, VisualEffect visualEffect, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, name, static (x, target, n) =>
+            {
+                target.SetInt(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectInt<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, VisualEffect visualEffect, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, (x, target) =>
+            {
+                target.SetFloat(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector2<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, VisualEffect visualEffect, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, name, static (x, target, n) =>
+            {
+                target.SetVector2(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector2<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, VisualEffect visualEffect, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, (x, target) =>
+            {
+                target.SetVector2(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector3<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, VisualEffect visualEffect, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, name, static (x, target, n) =>
+            {
+                target.SetVector3(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector3<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, VisualEffect visualEffect, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, (x, target) =>
+            {
+                target.SetVector3(nameID, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector4<TOptions, TAdapter>(this MotionBuilder<Vector4, TOptions, TAdapter> builder, VisualEffect visualEffect, string name)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector4, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, name, static (x, target, n) =>
+            {
+                target.SetVector4(n, x);
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to VisualEffect parameter.
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToVisualEffectVector4<TOptions, TAdapter>(this MotionBuilder<Vector4, TOptions, TAdapter> builder, VisualEffect visualEffect, int nameID)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector4, TOptions>
+        {
+            Error.IsNull(visualEffect);
+            return builder.BindWithState(visualEffect, (x, target) =>
+            {
+                target.SetVector4(nameID, x);
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/VisualEffectGragh/LitMotionVisualEffectExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 566c43e5a31124ac5b13f7c6951d1c30
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/uGUI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2224568bfb6ae449dba4e00b82c7484a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/uGUI/LitMotionRectTransformExtensions.cs

@@ -0,0 +1,314 @@
+using UnityEngine;
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for RectTransform.
+    /// </summary>
+    public static class LitMotionRectTransformExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPosition<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.anchoredPosition = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPositionX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var p = target.anchoredPosition;
+                p.x = x;
+                target.anchoredPosition = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPositionY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var p = target.anchoredPosition;
+                p.y = x;
+                target.anchoredPosition = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition3D
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPosition3D<TOptions, TAdapter>(this MotionBuilder<Vector3, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector3, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.anchoredPosition3D = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition3D.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPosition3DX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var p = target.anchoredPosition3D;
+                p.x = x;
+                target.anchoredPosition3D = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition3D.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPosition3DY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var p = target.anchoredPosition3D;
+                p.y = x;
+                target.anchoredPosition3D = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchoredPosition3D.z
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchoredPosition3DZ<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var p = target.anchoredPosition3D;
+                p.z = x;
+                target.anchoredPosition3D = p;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchorMin
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchorMin<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.anchorMin = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.anchorMax
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAnchorMax<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.anchorMax = x;
+            });
+        }
+
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.sizeDelta
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToSizeDelta<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.sizeDelta = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.sizeDelta.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToSizeDeltaX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var s = target.sizeDelta;
+                s.x = x;
+                target.sizeDelta = s;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.sizeDelta.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToSizeDeltaY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var s = target.sizeDelta;
+                s.y = x;
+                target.sizeDelta = s;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.pivot
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPivot<TOptions, TAdapter>(this MotionBuilder<Vector2, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Vector2, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                target.pivot = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.pivot.x
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPivotX<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var s = target.pivot;
+                s.x = x;
+                target.pivot = s;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to RectTransform.pivot.y
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToPivotY<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, RectTransform rectTransform)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(rectTransform);
+            return builder.BindWithState(rectTransform, static (x, target) =>
+            {
+                var s = target.pivot;
+                s.y = x;
+                target.pivot = s;
+            });
+        }
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/uGUI/LitMotionRectTransformExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40937bbeab5a94c94957a4ec3bf7e73c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/uGUI/LitMotionUGUIExtensions.cs

@@ -0,0 +1,401 @@
+#if LITMOTION_SUPPORT_UGUI
+using UnityEngine;
+using UnityEngine.UI;
+using Unity.Collections;
+#if LITMOTION_SUPPORT_ZSTRING
+using Cysharp.Text;
+#endif
+
+namespace LitMotion.Extensions
+{
+    /// <summary>
+    /// Provides binding extension methods for Unity UI (uGUI) components.
+    /// </summary>
+    public static class LitMotionUGUIExtensions
+    {
+        /// <summary>
+        /// Create a motion data and bind it to Graphic.color
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColor<TOptions, TAdapter>(this MotionBuilder<Color, TOptions, TAdapter> builder, Graphic graphic)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<Color, TOptions>
+        {
+            Error.IsNull(graphic);
+            return builder.BindWithState(graphic, static (x, target) =>
+            {
+                target.color = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Graphic.color.r
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorR<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Graphic graphic)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(graphic);
+            return builder.BindWithState(graphic, static (x, target) =>
+            {
+                var c = target.color;
+                c.r = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Graphic.color.g
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorG<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Graphic graphic)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(graphic);
+            return builder.BindWithState(graphic, static (x, target) =>
+            {
+                var c = target.color;
+                c.g = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Graphic.color.b
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorB<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Graphic graphic)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(graphic);
+            return builder.BindWithState(graphic, static (x, target) =>
+            {
+                var c = target.color;
+                c.b = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Graphic.color.a
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToColorA<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Graphic graphic)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(graphic);
+            return builder.BindWithState(graphic, static (x, target) =>
+            {
+                var c = target.color;
+                c.a = x;
+                target.color = c;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Image.FillAmount
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToFillAmount<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Image image)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(image);
+            return builder.BindWithState(image, static (x, target) =>
+            {
+                target.fillAmount = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to CanvasGroup.alpha
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToCanvasGroupAlpha<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, CanvasGroup canvasGroup)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(canvasGroup);
+            return builder.BindWithState(canvasGroup, static (x, target) =>
+            {
+                target.alpha = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.fontSize
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToFontSize<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.fontSize = x;
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString32Bytes, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString32Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString64Bytes, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString64Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString128Bytes, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString128Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString512Bytes, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString512Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<FixedString4096Bytes, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<FixedString4096Bytes, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ConvertToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<int, TOptions, TAdapter> builder, Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<int, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<long, TOptions, TAdapter> builder, Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<long, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Text text)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, static (x, target) =>
+            {
+                target.text = x.ToString();
+            });
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to Text.text
+        /// </summary>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="transform"></param>
+        /// <param name="format">Format string</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToText<TOptions, TAdapter>(this MotionBuilder<float, TOptions, TAdapter> builder, Text text, string format)
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<float, TOptions>
+        {
+            Error.IsNull(text);
+            return builder.BindWithState(text, format, static (x, target, format) =>
+            {
+#if LITMOTION_SUPPORT_ZSTRING
+                target.text = ZString.Format(format, x);
+#else
+                target.text = string.Format(format, x);
+#endif
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Extensions/uGUI/LitMotionUGUIExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 639ca89905ee74d02bfc3c04d9eb2269
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 33e518cd634f14e3ab97a11300c65238
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/R3.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8e2e973abce4a31438b6901111ed7a03
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/R3/LitMotionR3Extensions.cs

@@ -0,0 +1,54 @@
+#if LITMOTION_SUPPORT_R3
+using R3;
+
+namespace LitMotion
+{
+    public static class LitMotionR3Extensions
+    {
+        /// <summary>
+        /// Create the motion as Observable.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <returns>Observable of the created motion.</returns>
+        public static Observable<TValue> ToObservable<TValue, TOptions, TAdapter>(this MotionBuilder<TValue, TOptions, TAdapter> builder)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            var subject = new Subject<TValue>();
+            builder.SetCallbackData(subject, static (x, subject) => subject.OnNext(x));
+            builder.buffer.CallbackData.OnCompleteAction += () => subject.OnCompleted();
+            builder.buffer.CallbackData.OnCancelAction += () => subject.OnCompleted();
+            var scheduler = builder.buffer.Scheduler;
+            builder.SetMotionData();
+
+            builder.Schedule(scheduler, ref builder.buffer.Data, ref builder.buffer.CallbackData);
+            return subject;
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to ReactiveProperty.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="progress">Target object that implements IProgress</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToReactiveProperty<TValue, TOptions, TAdapter>(this MotionBuilder<TValue, TOptions, TAdapter> builder, ReactiveProperty<TValue> reactiveProperty)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            Error.IsNull(reactiveProperty);
+            return builder.BindWithState(reactiveProperty, static (x, target) =>
+            {
+                target.Value = x;
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/R3/LitMotionR3Extensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 78c4cfe16961d754ca0e1cd47cf6cccf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniRx.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: baca6bcdfea9f4791b2fdcce95b79bcd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniRx/LitMotionUniRxExtensions.cs

@@ -0,0 +1,58 @@
+#if LITMOTION_SUPPORT_UNIRX
+using System;
+using UniRx;
+
+namespace LitMotion
+{
+    /// <summary>
+    /// Provides extension methods for UniRx integration.
+    /// </summary>
+    public static class LitMotionUniRxExtensions
+    {
+        /// <summary>
+        /// Create the motion as IObservable.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <returns>Observable of the created motion.</returns>
+        public static IObservable<TValue> ToObservable<TValue, TOptions, TAdapter>(this MotionBuilder<TValue, TOptions, TAdapter> builder)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            var subject = new Subject<TValue>();
+            builder.SetCallbackData(subject, static (x, subject) => subject.OnNext(x));
+            builder.buffer.CallbackData.OnCompleteAction += () => subject.OnCompleted();
+            builder.buffer.CallbackData.OnCancelAction += () => subject.OnCompleted();
+            var scheduler = builder.buffer.Scheduler;
+            builder.SetMotionData();
+
+            builder.Schedule(scheduler, ref builder.buffer.Data, ref builder.buffer.CallbackData);
+            return subject;
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to ReactiveProperty.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="progress">Target object that implements IProgress</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToReactiveProperty<TValue, TOptions, TAdapter>(this MotionBuilder<TValue, TOptions, TAdapter> builder, ReactiveProperty<TValue> reactiveProperty)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            Error.IsNull(reactiveProperty);
+            return builder.BindWithState(reactiveProperty, static (x, target) =>
+            {
+                target.Value = x;
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniRx/LitMotionUniRxExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 56e6dc6dcf3124e808289b507cb6422d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniTask.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d43301b50fec5424d9750d75a8f48ff9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniTask/LitMotionUniTaskExtensions.cs

@@ -0,0 +1,59 @@
+#if LITMOTION_SUPPORT_UNITASK
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace LitMotion
+{
+    /// <summary>
+    /// Provides extension methods for UniTask integration.
+    /// </summary>
+    public static class LitMotionUniTaskExtensions
+    {
+        /// <summary>
+        /// Convert motion handle to UniTask.
+        /// </summary>
+        /// <param name="handle">This motion handle</param>
+        /// <param name="cancellationToken">CancellationToken</param>
+        /// <returns></returns>
+        public static UniTask ToUniTask(this MotionHandle handle, CancellationToken cancellationToken = default)
+        {
+            if (!handle.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(UniTaskMotionConfiguredSource.Create(handle, CancelBehaviour.CancelAndCancelAwait, cancellationToken, out var token), token);
+        }
+
+        /// <summary>
+        /// Convert motion handle to UniTask.
+        /// </summary>
+        /// <param name="handle">This motion handle</param>
+        /// <param name="cancelBehaviour">Behavior when canceling</param>
+        /// <param name="cancellationToken">CancellationToken</param>
+        /// <returns></returns>
+        public static UniTask ToUniTask(this MotionHandle handle, CancelBehaviour cancelBehaviour, CancellationToken cancellationToken = default)
+        {
+            if (!handle.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(UniTaskMotionConfiguredSource.Create(handle, cancelBehaviour, cancellationToken, out var token), token);
+        }
+
+        /// <summary>
+        /// Create a motion data and bind it to AsyncReactiveProperty.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="builder">This builder</param>
+        /// <param name="progress">Target object that implements IProgress</param>
+        /// <returns>Handle of the created motion data.</returns>
+        public static MotionHandle BindToAsyncReactiveProperty<TValue, TOptions, TAdapter>(this MotionBuilder<TValue, TOptions, TAdapter> builder, AsyncReactiveProperty<TValue> reactiveProperty)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
+        {
+            Error.IsNull(reactiveProperty);
+            return builder.BindWithState(reactiveProperty, static (x, target) =>
+            {
+                target.Value = x;
+            });
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniTask/LitMotionUniTaskExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 739d52a9a266143199639433f2ace9cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniTask/UniTaskMotionConfiguredSource.cs

@@ -0,0 +1,94 @@
+#if LITMOTION_SUPPORT_UNITASK
+using System;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace LitMotion
+{
+    internal sealed class UniTaskMotionConfiguredSource : MotionConfiguredSourceBase ,IUniTaskSource, ITaskPoolNode<UniTaskMotionConfiguredSource>
+    {
+        static UniTaskMotionConfiguredSource()
+        {
+            TaskPool.RegisterSizeGetter(typeof(UniTaskMotionConfiguredSource), () => pool.Size);
+        }
+
+        UniTaskMotionConfiguredSource() : base() { }
+
+        static TaskPool<UniTaskMotionConfiguredSource> pool;
+        UniTaskMotionConfiguredSource nextNode;
+        public ref UniTaskMotionConfiguredSource NextNode => ref nextNode;
+
+        UniTaskCompletionSourceCore<AsyncUnit> core;
+
+        public static IUniTaskSource Create(MotionHandle motionHandle, CancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                OnCanceledTokenReceived(motionHandle, cancelBehaviour);
+                return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+            }
+
+            if (!pool.TryPop(out var result))
+            {
+                result = new UniTaskMotionConfiguredSource();
+            }
+
+            result.Initialize(motionHandle, cancelBehaviour, cancellationToken);
+
+            TaskTracker.TrackActiveTask(result, 3);
+
+            token = result.core.Version;
+            return result;
+        }
+
+        protected override void SetTaskCanceled(CancellationToken cancellationToken)
+        {
+            core.TrySetCanceled(cancellationToken);
+        }
+
+        protected override void SetTaskCompleted()
+        {
+            core.TrySetResult(AsyncUnit.Default);
+        }
+        
+        public void GetResult(short token)
+        {
+            try
+            {
+                core.GetResult(token);
+            }
+            finally
+            {
+                TryReturn();
+            }
+        }
+
+        public UniTaskStatus GetStatus(short token)
+        {
+            return core.GetStatus(token);
+        }
+
+        public UniTaskStatus UnsafeGetStatus()
+        {
+            return core.UnsafeGetStatus();
+        }
+
+        public void OnCompleted(Action<object> continuation, object state, short token)
+        {
+            core.OnCompleted(continuation, state, token);
+        }
+
+        bool TryReturn()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            
+            DisposeRegistration();
+            RestoreOriginalCallback();
+            ResetFields();
+
+            return pool.TryPush(this);
+        }
+    }
+}
+#endif

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/External/UniTask/UniTaskMotionConfiguredSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: caa8d0184d2f1467081ea51ceea4bf7d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionAdapter.cs

@@ -0,0 +1,22 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Implement this interface to define animating values of a particular type.
+    /// </summary>
+    /// <typeparam name="TValue">The type of value to animate</typeparam>
+    /// <typeparam name="TOptions">The type of special parameters given to the motion entity</typeparam>
+    public interface IMotionAdapter<TValue, TOptions>
+        where TValue : unmanaged
+        where TOptions : unmanaged, IMotionOptions
+    {
+        /// <summary>
+        /// Define the process to interpolate the values between two points.
+        /// </summary>
+        /// <param name="startValue">Start value</param>
+        /// <param name="endValue">End value</param>
+        /// <param name="options">Option value to specify</param>
+        /// <param name="context">Animation context</param>
+        /// <returns>Current value</returns>
+        TValue Evaluate(ref TValue startValue, ref TValue endValue, ref TOptions options, in MotionEvaluationContext context);
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionAdapter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 32c2ed22a737d4d5084047cd0aafc6b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionOptions.cs

@@ -0,0 +1,7 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Implement this interface to define special options that can be applied to motion.
+    /// </summary>
+    public interface IMotionOptions { }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionOptions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9b69f9e41a6a244818a47732ab7adc7f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionScheduler.cs

@@ -0,0 +1,37 @@
+namespace LitMotion
+{
+    /// <summary>
+    /// Provides the function to schedule the execution of a motion.
+    /// </summary>
+    public interface IMotionScheduler
+    {
+        /// <summary>
+        /// Schedule the motion.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value to animate</typeparam>
+        /// <typeparam name="TOptions">The type of special parameters given to the motion data</typeparam>
+        /// <typeparam name="TAdapter">The type of adapter that support value animation</typeparam>
+        /// <param name="data">Motion data</param>
+        /// <param name="callbackData">Motion callback data</param>
+        /// <returns>Motion handle</returns>
+        MotionHandle Schedule<TValue, TOptions, TAdapter>(ref MotionData<TValue, TOptions> data, ref MotionCallbackData callbackData)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+            where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>;
+
+        /// <summary>
+        /// Returns the current time.
+        /// </summary>
+        double Time { get; }
+    }
+
+    /// <summary>
+    /// Type of time used to play the motion
+    /// </summary>
+    public enum MotionTimeKind : byte
+    {
+        Time = 0,
+        UnscaledTime = 1,
+        Realtime = 2
+    }
+}

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/IMotionScheduler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8ffdee48e8f41435c90f44012f7bf6d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2903c6b68697345e4ac563b3903cc7a0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.annulusgames.lit-motion@99e865bcf3/Runtime/Internal/ArrayHelper.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace LitMotion
+{
+    internal static class ArrayHelper
+    {
+        const int ArrayMaxSize = 0x7FFFFFC7;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void EnsureCapacity(ref char[] buffer, int minimumCapacity)
+        {
+            if (buffer == null)
+            {
+                Error.ArgumentNull(nameof(buffer));
+            }
+
+            var current = buffer.Length;
+            if (minimumCapacity > current)
+            {
+                int num = minimumCapacity;
+                if (num < 256)
+                {
+                    num = 256;
+                    FastResize(ref buffer, num);
+                    return;
+                }
+
+                if (current == ArrayMaxSize)
+                {
+                    throw new InvalidOperationException("char[] size reached maximum size of array(0x7FFFFFC7).");
+                }
+
+                var newSize = unchecked(current * 2);
+                if (newSize < 0)
+                {
+                    num = ArrayMaxSize;
+                }
+                else
+                {
+                    if (num < newSize)
+                    {
+                        num = newSize;
+                    }
+                }
+
+                FastResize(ref buffer, num);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void FastResize(ref char[] array, int newSize)
+        {
+            if (newSize < 0) throw new ArgumentOutOfRangeException(nameof(newSize));
+
+            char[] array2 = array;
+            if (array2 == null)
+            {
+                array = new char[newSize];
+                return;
+            }
+
+            if (array2.Length != newSize)
+            {
+                char[] array3 = new char[newSize];
+                Buffer.BlockCopy(array2, 0, array3, 0, (array2.Length > newSize) ? newSize : array2.Length);
+                array = array3;
+            }
+        }
+    }
+}