LitMotion v2.0

README.md

@@ -14,26 +14,31 @@ LitMotion is a high-performance tween library for Unity. LitMotion includes a ri
 
 LitMotion is my second tween library I created after [Magic Tween](https://github.com/AnnulusGames/MagicTween). LitMotion was designed based on experience implementing Magic Tween to achieve rich functionality and extremely high performance. In all situations such as creating and updating tweens, it exhibits overwhelming performance that is 2 to 20 times faster than other tween libraries. Of course, there is no allocation at all when creating a tween.
 
+![img](./docs/images/img-v2-available.png)
+
+Additionally, v2 introduces Sequence for combining multiple motions and the LitMotion.Animation package, which allows you to create tween animations directly from the Inspector. With these additions, LitMotion is now as powerful, if not more, than DOTween Pro or PrimeTween in terms of features.
+
 ## Documentation
 
 The full version of documentation can be found [here](https://annulusgames.github.io/LitMotion/).
 
 ## Features
 
-- Animate anything in one line of code.
-- Achieves zero allocations due to its struct-based design.
-- Highly optimized using DOTS (Data-Oriented Technology Stack).
-- Works in both runtime and editor.
-- Provides a rich set of schedulers, allowing you to specify the PlayerLoop to execute.
-- Apply complex settings like easing and looping.
-- Wait for completion via callbacks/coroutines.
-- Zero allocation string animation with FixedString and TextMeshPro
-- Character animation for TextMeshPro text.
-- Motion Tracker Window for monitoring motions in progress.
-- Convert to Observables using UniRx.
-- Convert to Observables using R3.
-- Supports async/await via UniTask.
-- Extend types using `IMotionOptions` and `IMotionAdapter`.
+* Animate anything in one line of code.
+* Achieves zero allocations with the struct-based design
+* Extremely high-performance implementation optimized using DOTS (Data-Oriented Technology Stack)
+* Works in both runtime and editor
+* Supports complex settings like easing and looping
+* Waits for completion using callbacks/coroutines
+* Zero allocation text animationSupports TextMesh Pro / UI Toolkit
+* Special motions like Punch, Shake, etc.
+* Conversion to Observable using [UniRx](https://github.com/neuecc/UniRx) / [R3](https://github.com/Cysharp/R3)
+* async/await support using [UniTask](https://github.com/Cysharp/UniTask)
+* Type extension with `IMotionOptions` and `IMotionAdapter`
+* Integration with the Inspector via `SerializableMotionSettings<T, TOptions>`
+* Debugging API and LitMotion Debugger window
+* Combine animations using `LSequence`
+* Create complex animations directly from the Inspector with the [LitMotion.Animation](articles/en/litmotion-animation-overview.md) package
 
 ## Setup
 
@@ -74,7 +79,7 @@ Here's a sample code. Refer to the documentation for more details.
 using System;
 using System.Threading;
 using UnityEngine;
-using UniRx; // UniRx
+using R3; // R3
 using Cysharp.Threading.Tasks; // UniTask
 using LitMotion;
 using LitMotion.Extensions;
@@ -157,12 +162,12 @@ public class Example : MonoBehaviour
         await handle.ToUniTask(cancellationToken); // Await with passing CancellationToken
     }
 
-    // Convert to IObservable<T> using UniRx
+    // Convert to Observable<T> using R3
     void RxExample()
     {
         LMotion.Create(0f, 1f, 2f)
-            .ToObservable() // Create motion as IObservable<T>
-            .Where(x => x > 0.5f) // Utilize UniRx operators
+            .ToObservable() // Create motion as Observable<T>
+            .Where(x => x > 0.5f) // Utilize R3 operators
             .Select(x => x.ToString())
             .Subscribe(x =>
             {
@@ -173,13 +178,59 @@ public class Example : MonoBehaviour
 }
 ```
 
-## Motion Tracker
+## Sequence
+
+The Sequence feature is provided for combining multiple motions.
+
+```cs
+LSequence.Create()
+    .Append(LMotion.Create(0f, 1f, 1f).BindToPositionX(transform))
+    .Join(LMotion.Create(0f, 1f, 1f).BindToPositionY(transform))
+    .Insert(0f, LMotion.Create(0f, 1f, 1f).BindToPositionZ(transform))
+    .Run();
+```
+
+For more details, refer to the [Sequence](https://annulusgames.github.io/LitMotion/ja/sequence.html) section in the documentation.
+
+## LitMotion.Animation
+
+LitMotion.Animation is an additional package that provides animation functionality built with LitMotion. 
+
+By introducing this package, you can use the LitMotion Animation component to construct animations in the Inspector.
+
+![img](./docs/images/img-litmotion-animation.gif)
+
+
+### Requirements
+
+* Unity 2021.3 or later
+* LitMotion 2.0.0 or later
+
+### Installation
+
+You can install LitMotion using the Package Manager.
+
+1. Open Package Manager by navigating to Window > Package Manager.
+2. Click on the "+" button and select "Add package from git URL."
+3. Enter the following URL:
+
+```text
+https://github.com/AnnulusGames/LitMotion.git?path=src/LitMotion/Assets/LitMotion.Animation
+```
+
+Alternatively, you can open the `Packages/manifest.json` file and add the following line within the `dependencies` block:
 
-You can track all active motions using the Motion Tracker Window.
+```json
+{
+    "dependencies": {
+        "com.annulusgames.lit-motion.animation": "https://github.com/AnnulusGames/LitMotion.git?path=src/LitMotion/Assets/LitMotion.Animation"
+    }
+}
+```
 
-<img src="https://annulusgames.github.io/LitMotion/images/motion-tracker-window.png" width="800">
+### How to Use
 
-For more details, please refer to [Motion Tracker](https://annulusgames.github.io/LitMotion/articles/en/motion-tracker.html).
+For how to use LitMotion.Animation, please refer to the documentation on [LitMotion.Animation](https://annulusgames.github.io/LitMotion/ja/litmotion-animation-overview.html).
 
 ## Performance
 

README_JA.md

@@ -14,26 +14,32 @@ LitMotionはUnity向けのハイパフォーマンスなトゥイーンライブ
 
 LitMotionは[Magic Tween](https://github.com/AnnulusGames/MagicTween)に続いて私が作成した2つ目のトゥイーンライブラリです。LitMotionはMagic Tweenの実装で得た経験をもとに、必要十分な機能を厳選しつつ、最速で動作させることを念頭に置いて設計されました。トゥイーンの作成や駆動などあらゆるシチュエーションにおいて、他のトゥイーンライブラリと比較して2倍から20倍以上の圧倒的なパフォーマンスを発揮します。当然、トゥイーン作成時のアロケーションも一切ありません。
 
+![img](./docs/images/img-v2-available.png)
+
+また、v2より複数のモーションを合成するためのSequenceと、Inspectorからトゥイーンアニメーションを作成可能なLitMotion.Animationパッケージが追加されました。これにより機能面においてもDOTween ProやPrimeTweenと同等または以上に強力なライブラリとなっています。
+
 ## ドキュメント
 
 ドキュメントのフルバージョンは[こちら](https://annulusgames.github.io/LitMotion/)から確認できます。
 
 ## 特徴
 
-- あらゆる値をコード一行でアニメーション可能
-- 構造体ベースの設計でゼロアロケーションを達成
-- DOTSを活用して最適化された極めてハイパフォーマンスな実装
-- ランタイムとエディタの両方で動作
-- 実行するPlayerLoopを指定する豊富なSchedulerを用意
-- イージングや繰り返しなど複雑な設定を適用可能
-- コールバック/コルーチンによる完了の待機
-- FixedStringとTextMeshProによるゼロアロケーションな文字列のアニメーション
-- TextMeshProのテキストを文字ごとにアニメーション可能
-- MotionTrackerウィンドウによる動作中のモーションの追跡
-- UniRxを利用したObservableへの変換
-- R3を利用したObservableへの変換
-- UniTaskを利用したasync/await対応
-- `IMotionOptions`と`IMotionAdapter`を用いた型の拡張
+* あらゆる値をコード一行でアニメーション可能
+* 構造体ベースの設計でゼロアロケーションを達成
+* DOTSを活用して最適化された極めてハイパフォーマンスな実装
+* ランタイムとエディタの両方で動作
+* イージングや繰り返しなど複雑な設定を適用可能
+* コールバック/コルーチンによる完了の待機
+* ゼロアロケーションなテキストアニメーション
+* TextMesh Pro / UI Toolkitに対応
+* Punch、Shakeなどの特殊なモーション
+* UniRx/R3を利用したObservableへの変換
+* UniTaskを利用したasync/await対応
+* `IMotionOptions`と`IMotionAdapter`を用いた型の拡張
+* `SerializableMotionSettings<T, TOptions>`によるInspectorとの統合
+* デバッグ用のAPIおよびLitMotion Debuggerウィンドウ
+* Sequenceによるアニメーションの合成
+* Inspectorから複雑なアニメーションを作成可能なLitMotion.Animationパッケージ
 
 ## セットアップ
 
@@ -74,7 +80,7 @@ LitMotionを用いることでTransformやMaterialなどの値を簡単にアニ
 using System;
 using System.Threading;
 using UnityEngine;
-using UniRx; // UniRx
+using R3; // R3
 using Cysharp.Threading.Tasks; // UniTask
 using LitMotion;
 using LitMotion.Extensions;
@@ -157,12 +163,12 @@ public class Example : MonoBehaviour
         await handle.ToUniTask(cancellationToken); // ToUniTaskでCancellationTokenを渡してawait
     }
 
-    // UniRxを利用したIObservable<T>への変換に対応
+    // R3を利用したObservable<T>への変換に対応
     void RxExample()
     {
         LMotion.Create(0f, 1f, 2f)
-            .ToObservable() // モーションをIObservable<T>として作成
-            .Where(x => x > 0.5f) // UniRxのオペレータを利用可能
+            .ToObservable() // モーションをObservable<T>として作成
+            .Where(x => x > 0.5f) // R3のオペレータを利用可能
             .Select(x => x.ToString())
             .Subscribe(x =>
             {
@@ -173,13 +179,54 @@ public class Example : MonoBehaviour
 }
 ```
 
-## Motion Tracker
+## Sequence
+
+複数のモーションを合成するための機能として、Sequenceが提供されています。
+
+```cs
+LSequence.Create()
+    .Append(LMotion.Create(0f, 1f, 1f).BindToPositionX(transform))
+    .Join(LMotion.Create(0f, 1f, 1f).BindToPositionY(transform))
+    .Insert(0f, LMotion.Create(0f, 1f, 1f).BindToPositionZ(transform))
+    .Run();
+```
+
+詳細はドキュメントの[Sequence](https://annulusgames.github.io/LitMotion/ja/sequence.html)を参照してください。
+
+## LitMotion.Animation
+
+LitMotion.AnimationはLitMotionで構築されたアニメーションの機能を提供する追加パッケージです。これを導入することで、Inspector上でアニメーションを構築できるLitMotion Animationコンポーネントが利用可能になります。
+
+![img](./docs/images/img-litmotion-animation.gif)
+
+### 要件
+
+* Unity 2021.3 以上
+* LitMotion 2.0.0 以上
+
+### インストール
+
+1. Window > Package ManagerからPackage Managerを開く
+2. 「+」ボタン > Add package from git URL
+3. 以下のURLを入力
+
+```text
+https://github.com/AnnulusGames/LitMotion.git?path=src/LitMotion/Assets/LitMotion.Animation
+```
+
+あるいはPackages/manifest.jsonを開き、dependenciesブロックに以下を追記します。
 
-Motion Trackerウィンドウを使用して動作中の全てのモーションを追跡できます。
+```json
+{
+    "dependencies": {
+        "com.annulusgames.lit-motion.animation": "https://github.com/AnnulusGames/LitMotion.git?path=src/LitMotion/Assets/LitMotion.Animation"
+    }
+}
+```
 
-<img src="https://annulusgames.github.io/LitMotion/images/motion-tracker-window.png" width="800">
+### 使い方
 
-詳細は[Motion Tracker](https://annulusgames.github.io/LitMotion/articles/ja/motion-tracker.html)を参照してください。
+LitMotion.Animationの使い方はドキュメントの[LitMotion.Animation](https://annulusgames.github.io/LitMotion/ja/litmotion-animation-overview.html)を参照してください。
 
 ## パフォーマンス
 

docs/articles/en/avoiding-dynamic-memory-allocation.md → docs/articles/en/avoid-dynamic-memory-allocation.md

@@ -1,4 +1,4 @@
-## Avoiding Dynamic Memory Allocation
+## Avoid Dynamic Memory Allocation
 
 You can expand the capacity of the internal array that holds motions beforehand by calling `MotionDispatcher.EnsureStorageCapacity()`. By ensuring the maximum anticipated capacity, such as during the app's startup, you can mitigate runtime dynamic memory allocation.
 

docs/articles/en/await-motion-in-async-await.md

@@ -0,0 +1,49 @@
+# Await Motion in async/await
+
+`MotionHandle` implements the `GetAwaiter()` method, allowing you to directly await it to wait for completion.
+
+```cs
+await handle;
+```
+
+If you want to pass a `CancellationToken`, you can use `ToValueTask()` / `ToAwaitable()` or UniTask.
+
+## ValueTask
+
+You can convert a motion to a `ValueTask` using `MotionHandle.ToValueTask()`. This allows you to use async/await to wait for the completion of the motion.
+
+```cs
+async ValueTask ExampleAsync(CancellationToken cancellationToken)
+{
+    await LMotion.Create(0f, 10f, 1f)
+        .RunWithoutBinding()
+        .ToValueTask(cancellationToken);
+}
+```
+
+However, using `ValueTask` in Unity has some performance concerns. For the best performance, it is recommended to use UniTask. For integration with UniTask, refer to the [UniTask](integration-unitask.md) guide.
+
+### Awaitable
+
+Starting from Unity 2023.1, Unity provides the [Awaitable](https://docs.unity3d.com/2023.1/Documentation/ScriptReference/Awaitable.html) class to enable efficient async/await handling within Unity.
+
+If you're using Unity 2023.1 or later, LitMotion provides the `ToAwaitable()` extension method to convert a `MotionHandle` to an `Awaitable`. This allows you to use async/await to wait for motion completion.
+
+```cs
+async Awaitable ExampleAsync(CancellationToken cancellationToken)
+{
+    await LMotion.Create(0f, 10f, 1f)
+        .RunWithoutBinding()
+        .ToAwaitable(cancellationToken);
+}
+```
+
+### Changing Behavior on Cancellation
+
+By specifying `CancelBehavior` in the arguments for `ToValueTask()` / `ToAwaitable()`, you can change the behavior when the async method is canceled. Additionally, setting `cancelAwaitOnMotionCanceled` to `true` allows the async method to be canceled when the `MotionHandle` is canceled.
+
+```cs
+await LMotion.Create(0f, 10f, 1f)
+    .RunWithoutBinding()
+    .ToAwaitable(CancelBehavior.Complete, true, cancellationToken);
+```