diff --git a/README.md b/README.md index 2d40660..7f8096c 100644 --- a/README.md +++ b/README.md @@ -4,13 +4,18 @@ Core Game Libraries for Unity ![](https://img.shields.io/badge/unity-2022.3%20or%20later-green?logo=unity) [![](https://img.shields.io/badge/license-MIT-blue)](https://github.com/mewlist/MewCore/blob/main/LICENSE) +## Readme (日本語) + +[Readme_ja.md](./README_ja.md) + ## Documents https://mewlist.github.io/MewCore/ -## Readme (日本語) +## Features -[Readme_ja.md](./README_ja.md) +* TaskQueue: a library for executing asynchronous functions in series +* TaskInterval: a library for running asynchronous functions at regular intervals ## Installation @@ -22,16 +27,16 @@ git@github.com:mewlist/MewCore.git ## TaskQueue -TaskQueue is a library that simplifies and efficiently handles asynchronous processes in Unity development. This library enables the management of dynamically changing asynchronous functions and the determination of execution order based on priority. +TaskQueue is a library for handling serial processing of asynchronous functions in Unity development. +Asynchronous functions are executed in the order they are input into the queue. +It also has the feature of a priority queue, which allows you to prioritize important tasks. ### Main Features -Dynamic Function Addition: Allows adding asynchronous functions to the task queue at runtime. This enables flexible response to changing requirements and situations. -Priority-Based Execution Management: Sets priorities for each asynchronous function and processes important tasks preferentially. This prevents delays in critical processes. - -Serial Processing and Safety: Executes multiple asynchronous functions in order, waiting for one function to complete before starting the next. This improves safety in UI updates and game sequencing. - -Simple Description: TaskQueue is designed to simplify the description of executing asynchronous functions. +* ***Dynamic Function Addition***: You can add asynchronous functions to the task queue at runtime. This allows you to flexibly respond to changing requirements and situations. +* ***Execution management based on priority***: You can set a priority for each asynchronous function and process important tasks preferentially. This prevents delays in important processing. +* ***Serial processing and safety***: Multiple asynchronous functions are executed in order and wait for the completion of one function before starting the execution of the next. This improves the safety of UI updates and game sequences. +* ***Maximum size of the queue***: You can set the maximum number of tasks that can be input into the queue. This allows you to prevent tasks from building up in the queue. ### Use Scenarios @@ -50,13 +55,11 @@ class Sample : Monobehaviour { void Start() { - // Create an instance of TaskQueue. var taskQueue = new TaskQueue(); - // Start executing TaskQueue. - // Passing destroyCancellationToken will automatically stop the process and dispose of it when the MonoBehaviour is destroyed. + // By passing the destroyCancellationToken, processing is automatically stoppped and disposed when MonoBehaviour is destroyed. taskQueue.Start(destroyCancellationToken); - // Add asynchronous functions to TaskQueue. + // Add an asynchronous function to TaskQueue. taskQueue.Enqueue(async cancellationToken => { Debug.Log("Hello"); @@ -81,34 +84,40 @@ Bye ### Executing Priority Tasks -You can execute priority tasks by specifying the priority as the second argument in Enqueue. -The lower the number, the more prioritized the processing. The default value is 0. +You can execute priority tasks by specifying the priority as the second argument to Enqueue. +The processing with a smaller ```priority``` value is prioritized. The default value is 0. ```csharp taskQueue.Enqueue(async ct => { ... }, priority: 1); +taskQueue.Enqueue(async ct => { ... }, priority: 0); // This task is processed first ``` -### Specifying PlayerLoop - -You can specify the PlayerLoop timing for processing the queue. -The following timing types are defined. +### Setting the Maximum Queue Size -| Timing | Description | -|-------------------------|------| -| `MewUnityEarlyUpdate` | Called at the beginning of Unity's frame update. At this stage, initial event processing and input updates occur. | -| `MewUnityFixedUpdate` | The timing for physics updates. Corresponds to fixed-frame-rate processing in Unity Engine. | -| `MewUnityPreUpdate` | Processing executed before the Update method. Includes scene state updates and animation updates. | -| `MewUnityUpdate` | The normal Update method timing, mainly used for updating game logic. | -| `MewUnityPreLateUpdate` | Processing executed before LateUpdate. Some post-processing for cameras and animations may occur. | -| `MewUnityPostLateUpdate` | Processing at the end of the frame, including rendering preparation and final camera updates. | +#### TaskQueueLimitType.Discard -To specify PlayerLoop timing, specify the timing type in the constructor. -For example, specifying MewUnityFixedUpdate can prevent queue processing delays in case of frame skips. +If you add tasks to a queue with a maximum size of 2 as follows, +and exceed the maximum number, the last added task is discarded. ```csharp -var fixedUpdateTaskQueue = new TaskQueue(); +taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... }); // This task is discarded ``` +#### TaskQueueLimitType.SwapLat + +If you add tasks to a queue with a maximum size of 2 as follows, +and exceed the maximum number, the last task is replaced. +If the queue is made up of tasks that have a higher priority than the task to be added, no replacement will be made. + +```csharp +taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... }); // This task is discarded +taskQueue.Enqueue(async ct => { ... }); +``` ## TaskInterval diff --git a/README_ja.md b/README_ja.md index 4a7941f..c4f1a90 100644 --- a/README_ja.md +++ b/README_ja.md @@ -4,6 +4,15 @@ Core Game Libraries for Unity ![](https://img.shields.io/badge/unity-2022.3%20or%20later-green?logo=unity) [![](https://img.shields.io/badge/license-MIT-blue)](https://github.com/mewlist/MewCore/blob/main/LICENSE) +## ドキュメント + +https://mewlist.github.io/MewCore/ + +## 機能 + +* TaskQueue: 非同期関数を直列実行するためのライブラリ +* TaskInterval: 非同期関数を一定間隔で実行するためのライブラリ + ## インストール UPM 経由でインストールすることができます。 @@ -14,29 +23,25 @@ git@github.com:mewlist/MewCore.git ## TaskQueue -TaskQueue は、Unity 開発における非同期処理を簡素化し、効率的に扱うためのライブラリです。このライブラリは、動的に変化する非同期関数の管理と、優先度に基づいた実行順序の決定を可能にします。 +TaskQueue は Unity 開発における**非同期関数の直列処理**を行うためのライブラリです。 +キューに入力した順で非同期関数が実行されます。 +また、優先度付きキューの機能も備えており、重要なタスクを優先的に実行することができます。 ### 主な特徴 -動的な関数追加: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。 - -優先度に基づく実行管理: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。 - -直列処理と安全性: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。 - -シンプルな記述: TaskQueue は、非同期関数の実行を簡単に記述できるように設計されています。 +* ***動的な関数追加***: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。 +* ***優先度に基づく実行管理***: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。 +* ***直列処理と安全性***: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。 +* ***キューの最大サイズ***: キューに入力できるタスクの最大数を設定できます。これにより、キューにタスクが溜まりすぎることを防ぐことができます。 +* ***シンプルな記述***: シンプルに記述できるように設計されています。 ### 使用シナリオ -UIの動的更新: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。 - -ゲームイベントのシーケンシング: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。 - -TaskQueue を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。 - -コマンドパターンへの適応: 非同期処理を含めたコマンドパターンの実装に適しています。 - -UI イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。 +* ***UIの動的更新***: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。 +* ***ゲームイベントのシーケンシング***: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。 +* ***TaskQueue*** を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。 +* ***コマンドパターンへの適応***: 非同期処理を含めたコマンドパターンの実装に適しています。 +* ***UI*** イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。 ### サンプルコード @@ -45,9 +50,7 @@ class Sample : Monobehaviour { void Start() { - // TaskQueue のインスタンスを生成します。 var taskQueue = new TaskQueue(); - // TaskQueue の実行を開始します。 // destroyCancellationToken を渡すことで // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。 taskQueue.Start(destroyCancellationToken); @@ -78,31 +81,36 @@ Bye ### 優先度付きタスクの実行 Enqueue の第二引数に優先度を指定することで、優先度付きタスクを実行することができます。 -```priotiry'''値が小さい処理が優先されます。既定値は 0 です。 +```priotiry```値が小さい処理が優先されます。既定値は 0 です。 ```csharp taskQueue.Enqueue(async ct => { ... }, priority: 1); +taskQueue.Enqueue(async ct => { ... }, priority: 0); // このタスクが優先して処理される ``` -### PlayerLoop の指定 +### キュー最大サイズの設定 -Queue を処理する PlayerLoop のタイミングを指定することができます。 -以下のタイミング型が定義されています。 +#### TaskQueueLimitType.Discard -| タイミング | 説明 | -|-------------------------|------| -| `MewUnityEarlyUpdate` | Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 | -| `MewUnityFixedUpdate` | 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 | -| `MewUnityPreUpdate` | `Update` メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 | -| `MewUnityUpdate` | 主にゲームロジックの更新に使用される、通常の `Update` メソッドのタイミングです。 | -| `MewUnityPreLateUpdate` | `LateUpdate` の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 | -| `MewUnityPostLateUpdate` | フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 | +最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後に追加されたタスクが破棄されます。 -PlayerLoop のタイミングを指定するには、コンストラクタにタイミング型を指定します。 -例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にキューの処理が遅延することを防くことができます。 +```csharp +taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... });　// このタスクが破棄される +``` + +#### TaskQueueLimitType.SwapLat + +最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後のタスクを入れ替えます。 +追加されるタスクより優先度が高いタスクでキューが構成される場合は、入れ替えは行われません。 ```csharp -var fixedUpdateTaskQueue = new TaskQueue(); +taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); +taskQueue.Enqueue(async ct => { ... }); +taskQueue.Enqueue(async ct => { ... });　// このタスクが破棄される +taskQueue.Enqueue(async ct => { ... });　 ``` ## TaskInterval @@ -170,12 +178,13 @@ public class Sample : MonoBahaviour ### 使用する Timer の指定 Create の第３引数に Timer の種類を指定することで、使用する Timer を変更することができます。 +Unity の Time.timeScale の影響を受けないようにしたい場合は、```IntervalTimerType.UnityTime``` 以外の値を指定するとよいでしょう。 -| Timer の種類 | 説明 | -|--------------|---------------------------| -| `IntervalTimerType.SystemTime` | システム時間を使用します。 | -| `IntervalTimerType.UnityTime` | Unity の Time.time を使用します。 | -| `IntervalTimerType.UnityUnscaledTime` | Time.unscaledTime を使用します。| +| Timer の種類 | 説明 | +|--------------|-----------------------------| +| `IntervalTimerType.SystemTime` | システム時間を使用します。 | +| `IntervalTimerType.UnityTime` | Unity の Time.time を使用します。(***規定値***) | +| `IntervalTimerType.UnityUnscaledTime` | Time.unscaledTime を使用します。 | Time.timeScale の影響を受けずに処理を実行する例。 @@ -184,27 +193,3 @@ TaskInterval .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken); ``` - -### PlayerLoop の指定 - -タスクを処理する PlayerLoop のタイミングを指定することができます。 -以下のタイミング型が定義されています。 - -| タイミング | 説明 | -|-------------------------|------| -| `MewUnityEarlyUpdate` | Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 | -| `MewUnityFixedUpdate` | 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 | -| `MewUnityPreUpdate` | `Update` メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 | -| `MewUnityUpdate` | 主にゲームロジックの更新に使用される、通常の `Update` メソッドのタイミングです。 | -| `MewUnityPreLateUpdate` | `LateUpdate` の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 | -| `MewUnityPostLateUpdate` | フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 | - -PlayerLoop のタイミングを指定するには、TaskIntervalに対してタイミング型を指定します。 -例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にも安定したゲーム時間でのタスク実行を行い遅延することを防くことができます。 - -```csharp -TaskInterval - .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) - .Start(destroyCancellationToken); -``` - diff --git a/docs/api/Mew.Core.Tasks.TaskQueue-1.html b/docs/api/Mew.Core.Tasks.TaskQueue-1.html index 05f3622..6886d9c 100644 --- a/docs/api/Mew.Core.Tasks.TaskQueue-1.html +++ b/docs/api/Mew.Core.Tasks.TaskQueue-1.html @@ -91,7 +91,7 @@
Table of Contents

Class TaskQueue<T> - +

@@ -205,7 +205,7 @@

Constructors

TaskQueue() - +

@@ -232,7 +232,7 @@

TaskQueue(TaskQueueLimitType, int) - +

@@ -265,7 +265,7 @@

Parameters

- Edit this page + Edit this page
diff --git a/docs/api/Mew.Core.Tasks.TaskQueue.html b/docs/api/Mew.Core.Tasks.TaskQueue.html index 6baa53e..5d00310 100644 --- a/docs/api/Mew.Core.Tasks.TaskQueue.html +++ b/docs/api/Mew.Core.Tasks.TaskQueue.html @@ -91,7 +91,7 @@
Table of Contents

Class TaskQueue - +

@@ -170,7 +170,7 @@

Constructors

TaskQueue(TaskQueueLimitType, int) - +

@@ -206,7 +206,7 @@

Fields

loopId - +

@@ -241,7 +241,7 @@

Properties

Count - +

Count of running or waiting tasks.

@@ -273,7 +273,7 @@

Property Value

Disposed - +

true if disposed.

@@ -305,7 +305,7 @@

Property Value

LimitType - +

@@ -336,10 +336,11 @@

Property Value

MaxSize - +

-
+

Max size of queue.

+
@@ -367,7 +368,7 @@

Property Value

Started - +

true if started.

@@ -403,7 +404,7 @@

Methods

Any() - +

@@ -434,7 +435,7 @@

Returns

Dispose() - +

@@ -460,7 +461,7 @@

Enqueue(TaskAction, int) - +

Enqueue task.

@@ -504,7 +505,7 @@

Exceptions

EnqueueAsync(TaskAction, int) - +

Enqueue task.

@@ -553,7 +554,7 @@

Exceptions

Start(CancellationToken?) - +

Start TaskQueue.

@@ -591,7 +592,7 @@

Exceptions

- Edit this page + Edit this page
diff --git a/docs/index.json b/docs/index.json index a18ddb3..c69a00c 100644 --- a/docs/index.json +++ b/docs/index.json @@ -87,7 +87,7 @@ "api/Mew.Core.Tasks.TaskQueue.html": { "href": "api/Mew.Core.Tasks.TaskQueue.html", "title": "Class TaskQueue | MewCore", - "keywords": "Class TaskQueue Namespace Mew.Core.Tasks Assembly Mew.Core.dll public class TaskQueue : IDisposable Inheritance object TaskQueue Implements IDisposable Derived TaskQueue Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Constructors TaskQueue(TaskQueueLimitType, int) public TaskQueue(TaskQueueLimitType taskQueueLimitType = TaskQueueLimitType.None, int maxSize = 0) Parameters taskQueueLimitType TaskQueueLimitType maxSize int Fields loopId protected string loopId Field Value string Properties Count Count of running or waiting tasks. public int Count { get; } Property Value int Disposed true if disposed. public bool Disposed { get; } Property Value bool LimitType public TaskQueueLimitType LimitType { get; } Property Value TaskQueueLimitType MaxSize public int MaxSize { get; } Property Value int Started true if started. public bool Started { get; } Property Value bool Methods Any() public bool Any() Returns bool Dispose() public void Dispose() Enqueue(TaskAction, int) Enqueue task. public void Enqueue(TaskAction func, int priority = 0) Parameters func TaskAction priority int Low number is prior. default is 0 Exceptions ObjectDisposedException InvalidOperationException ArgumentOutOfRangeException EnqueueAsync(TaskAction, int) Enqueue task. public TaskQueueAwaitable EnqueueAsync(TaskAction func, int priority = 0) Parameters func TaskAction priority int Low number is prior. default is 0 Returns TaskQueueAwaitable Exceptions ObjectDisposedException InvalidOperationException ArgumentOutOfRangeException Start(CancellationToken?) Start TaskQueue. public void Start(CancellationToken? ct = null) Parameters ct CancellationToken? Dispose TaskQueue when ct is cancelled. Exceptions ObjectDisposedException" + "keywords": "Class TaskQueue Namespace Mew.Core.Tasks Assembly Mew.Core.dll public class TaskQueue : IDisposable Inheritance object TaskQueue Implements IDisposable Derived TaskQueue Inherited Members object.Equals(object) object.Equals(object, object) object.GetHashCode() object.GetType() object.MemberwiseClone() object.ReferenceEquals(object, object) object.ToString() Constructors TaskQueue(TaskQueueLimitType, int) public TaskQueue(TaskQueueLimitType taskQueueLimitType = TaskQueueLimitType.None, int maxSize = 0) Parameters taskQueueLimitType TaskQueueLimitType maxSize int Fields loopId protected string loopId Field Value string Properties Count Count of running or waiting tasks. public int Count { get; } Property Value int Disposed true if disposed. public bool Disposed { get; } Property Value bool LimitType public TaskQueueLimitType LimitType { get; } Property Value TaskQueueLimitType MaxSize Max size of queue. public int MaxSize { get; } Property Value int Started true if started. public bool Started { get; } Property Value bool Methods Any() public bool Any() Returns bool Dispose() public void Dispose() Enqueue(TaskAction, int) Enqueue task. public void Enqueue(TaskAction func, int priority = 0) Parameters func TaskAction priority int Low number is prior. default is 0 Exceptions ObjectDisposedException InvalidOperationException ArgumentOutOfRangeException EnqueueAsync(TaskAction, int) Enqueue task. public TaskQueueAwaitable EnqueueAsync(TaskAction func, int priority = 0) Parameters func TaskAction priority int Low number is prior. default is 0 Returns TaskQueueAwaitable Exceptions ObjectDisposedException InvalidOperationException ArgumentOutOfRangeException Start(CancellationToken?) Start TaskQueue. public void Start(CancellationToken? ct = null) Parameters ct CancellationToken? Dispose TaskQueue when ct is cancelled. Exceptions ObjectDisposedException" }, "api/Mew.Core.Tasks.TaskQueueAwaitable.html": { "href": "api/Mew.Core.Tasks.TaskQueueAwaitable.html", @@ -152,7 +152,12 @@ "ja/TaskInterval/index.html": { "href": "ja/TaskInterval/index.html", "title": "TaskInterval | MewCore", - "keywords": "TaskInterval TaskInterval は、Unity 開発で一定間隔による特定の処理の実行を容易にするライブラリです。このライブラリは、非同期関数を定期的に実行し、複数の非同期処理が並行して実行されることを防ぎます。 主な特徴 非同期関数の定期実行: 指定された間隔ごとに非同期関数を自動的に実行します。これにより、非同期処理を含むタスクの管理が容易になります。 処理時間への柔軟な対応: 非同期関数の実行に時間がかかり、指定した間隔を超えた場合でも、処理をスキップするか、遅れても実行を継続することができます。これは一般的な定期実行処理とは異なり、よりリアルタイムの動作環境に適応します。 並行実行の防止: 一度に一つの非同期処理のみが実行され、複数の処理が同時に実行されることはありません。これにより、タスクの実行が予測可能で安全になります。 安定した間隔での実行: 同期関数を使用すれば、安定した間隔で関数を実行することも可能です。 使用シナリオ ゲーム内の定期的な更新: ゲームの状態やオブジェクトの状態を一定間隔で更新する際に利用します。 バックグラウンド処理: ネットワーク通信やデータの読み込みなど、バックグラウンドでの定期的な処理に適しています。 UIの定期的な更新: ユーザーインターフェースの要素を定期的に更新する際にも利用できます。 TaskInterval を使用することで、Unity 開発における定期的な処理の実装がより柔軟かつ効率的になり、並行実行による問題を防ぎます。 サンプルコード public class Sample : MonoBahaviour { private void Awake() { // 一秒ごとに TestTaskAsync を実行する TaskInterval を生成します。 // destroyCancellationToken を渡すことで // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。 TaskInterval .Create(TimeSpan.FromSeconds(1), TestTaskAsync) .Start(destroyCancellationToken); } private float time; private async Task TestTaskAsync(CancellationToken ct) { var currentTime = Time.time; Debug.Log($\"{currentTime - time}\"); time = currentTime; await Task.Delay(100, ct); } } 実行結果 0.9996152 1.000825 1.000599 0.9999266 1.000448 0.9925194 ... 使用する Timer の指定 Create の第３引数に Timer の種類を指定することで、使用する Timer を変更することができます。 Timer の種類 説明 IntervalTimerType.SystemTime システム時間を使用します。 IntervalTimerType.UnityTime Unity の Time.time を使用します。 IntervalTimerType.UnityUnscaledTime Time.unscaledTime を使用します。 Time.timeScale の影響を受けずに処理を実行する例。 TaskInterval .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken); PlayerLoop の指定 タスクを処理する PlayerLoop のタイミングを指定することができます。 以下のタイミング型が定義されています。 タイミング 説明 MewUnityEarlyUpdate Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 MewUnityFixedUpdate 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 MewUnityPreUpdate Update メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 MewUnityUpdate 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。 MewUnityPreLateUpdate LateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 MewUnityPostLateUpdate フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 PlayerLoop のタイミングを指定するには、TaskIntervalに対してタイミング型を指定します。 例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にも安定したゲーム時間でのタスク実行を行い遅延することを防くことができます。 TaskInterval .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken);" + "keywords": "TaskInterval TaskInterval は、Unity 開発で一定間隔による特定の処理の実行を容易にするライブラリです。このライブラリは、非同期関数を定期的に実行し、複数の非同期処理が並行して実行されることを防ぎます。 主な特徴 非同期関数の定期実行: 指定された間隔ごとに非同期関数を自動的に実行します。これにより、非同期処理を含むタスクの管理が容易になります。 処理時間への柔軟な対応: 非同期関数の実行に時間がかかり、指定した間隔を超えた場合でも、処理をスキップするか、遅れても実行を継続することができます。これは一般的な定期実行処理とは異なり、よりリアルタイムの動作環境に適応します。 並行実行の防止: 一度に一つの非同期処理のみが実行され、複数の処理が同時に実行されることはありません。これにより、タスクの実行が予測可能で安全になります。 安定した間隔での実行: 同期関数を使用すれば、安定した間隔で関数を実行することも可能です。 使用シナリオ ゲーム内の定期的な更新: ゲームの状態やオブジェクトの状態を一定間隔で更新する際に利用します。 バックグラウンド処理: ネットワーク通信やデータの読み込みなど、バックグラウンドでの定期的な処理に適しています。 UIの定期的な更新: ユーザーインターフェースの要素を定期的に更新する際にも利用できます。 TaskInterval を使用することで、Unity 開発における定期的な処理の実装がより柔軟かつ効率的になり、並行実行による問題を防ぎます。 サンプルコード public class Sample : MonoBahaviour { private void Awake() { // 一秒ごとに TestTaskAsync を実行する TaskInterval を生成します。 // destroyCancellationToken を渡すことで // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。 TaskInterval .Create(TimeSpan.FromSeconds(1), TestTaskAsync) .Start(destroyCancellationToken); } private float time; private async Task TestTaskAsync(CancellationToken ct) { var currentTime = Time.time; Debug.Log($\"{currentTime - time}\"); time = currentTime; await Task.Delay(100, ct); } } 実行結果 0.9996152 1.000825 1.000599 0.9999266 1.000448 0.9925194 ... 使用する Timer の指定 Create の第３引数に Timer の種類を指定することで、使用する Timer を変更することができます。 Timer の種類 説明 IntervalTimerType.SystemTime システム時間を使用します。 IntervalTimerType.UnityTime Unity の Time.time を使用します。 IntervalTimerType.UnityUnscaledTime Time.unscaledTime を使用します。 Time.timeScale の影響を受けずに処理を実行する例。 TaskInterval .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken);" + }, + "ja/TaskInterval/player-loop.html": { + "href": "ja/TaskInterval/player-loop.html", + "title": "PlayerLoop の指定 | MewCore", + "keywords": "PlayerLoop の指定 タスクを処理する PlayerLoop のタイミングを指定することができます。 以下のタイミング型が定義されています。 タイミング 説明 MewUnityEarlyUpdate Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 MewUnityFixedUpdate 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 MewUnityPreUpdate Update メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 MewUnityUpdate 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。 MewUnityPreLateUpdate LateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 MewUnityPostLateUpdate フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 PlayerLoop のタイミングを指定するには、TaskIntervalに対してタイミング型を指定します。 例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にも安定したゲーム時間でのタスク実行を行い遅延することを防くことができます。 TaskInterval .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken);" }, "ja/TaskQueue/awaitable.html": { "href": "ja/TaskQueue/awaitable.html", @@ -167,7 +172,12 @@ "ja/TaskQueue/index.html": { "href": "ja/TaskQueue/index.html", "title": "TaskQueue | MewCore", - "keywords": "TaskQueue TaskQueue は、Unity 開発における非同期処理を簡素化し、効率的に扱うためのライブラリです。このライブラリは、動的に変化する非同期関数の管理と、優先度に基づいた実行順序の決定を可能にします。 主な特徴 動的な関数追加: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。 優先度に基づく実行管理: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。 直列処理と安全性: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。 シンプルな記述: TaskQueue は、非同期関数の実行を簡単に記述できるように設計されています。 使用シナリオ UIの動的更新: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。 ゲームイベントのシーケンシング: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。 TaskQueue を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。 コマンドパターンへの適応: 非同期処理を含めたコマンドパターンの実装に適しています。 UI イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。 サンプルコード class Sample : Monobehaviour { void Start() { // TaskQueue のインスタンスを生成します。 var taskQueue = new TaskQueue(); // TaskQueue の実行を開始します。 // destroyCancellationToken を渡すことで // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。 taskQueue.Start(destroyCancellationToken); // TaskQueue に非同期関数を追加します。 taskQueue.Enqueue(async cancellationToken => { Debug.Log(\"Hello\"); await Task.Delay(1000, cancellationToken); }); taskQueue.Enqueue(async cancellationToken => { await Task.Delay(1000, cancellationToken); Debug.Log(\"Bye\"); }); } } 実行結果 Hello // 二秒後 Bye 優先度付きタスクの実行 Enqueue の第二引数に優先度を指定することで、優先度付きタスクを実行することができます。 priority値が低いほど処理が優先されます。既定値は 0 です。 taskQueue.Enqueue(async ct => { ... }, priority: 1); PlayerLoop の指定 Queue を処理する PlayerLoop のタイミングを指定することができます。 以下のタイミング型が定義されています。 タイミング 説明 MewUnityEarlyUpdate Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 MewUnityFixedUpdate 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 MewUnityPreUpdate Update メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 MewUnityUpdate (既定値) 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。 MewUnityPreLateUpdate LateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 MewUnityPostLateUpdate フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 PlayerLoop のタイミングを指定するには、コンストラクタにタイミング型を指定します。 例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にキューの処理が遅延することを防くことができます。 var fixedUpdateTaskQueue = new TaskQueue();" + "keywords": "TaskQueue TaskQueue は Unity 開発における非同期関数の直列処理を行うためのライブラリです。 キューに入力した順で非同期関数が実行されます。 また、優先度付きキューの機能も備えており、重要なタスクを優先的に実行することができます。 主な特徴 動的な関数追加: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。 優先度に基づく実行管理: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。 直列処理と安全性: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。 キューの最大サイズ: キューに入力できるタスクの最大数を設定できます。これにより、キューにタスクが溜まりすぎることを防ぐことができます。 シンプルな記述: シンプルに記述できるように設計されています。 使用シナリオ UIの動的更新: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。 ゲームイベントのシーケンシング: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。 TaskQueue を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。 コマンドパターンへの適応: 非同期処理を含めたコマンドパターンの実装に適しています。 UI イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。 サンプルコード class Sample : Monobehaviour { void Start() { var taskQueue = new TaskQueue(); // destroyCancellationToken を渡すことで // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。 taskQueue.Start(destroyCancellationToken); // TaskQueue に非同期関数を追加します。 taskQueue.Enqueue(async cancellationToken => { Debug.Log(\"Hello\"); await Task.Delay(1000, cancellationToken); }); taskQueue.Enqueue(async cancellationToken => { await Task.Delay(1000, cancellationToken); Debug.Log(\"Bye\"); }); } } 実行結果 Hello // 二秒後 Bye 優先度付きタスクの実行 Enqueue の第二引数に優先度を指定することで、優先度付きタスクを実行することができます。 priotiry値が小さい処理が優先されます。既定値は 0 です。 taskQueue.Enqueue(async ct => { ... }, priority: 1); taskQueue.Enqueue(async ct => { ... }, priority: 0); // このタスクが優先して処理される キュー最大サイズの設定 TaskQueueLimitType.Discard 最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後に追加されたタスクが破棄されます。 taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); taskQueue.Enqueue(async ct => { ... }); taskQueue.Enqueue(async ct => { ... }); taskQueue.Enqueue(async ct => { ... }); // このタスクが破棄される TaskQueueLimitType.SwapLat 最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後のタスクを入れ替えます。 追加されるタスクより優先度が高いタスクでキューが構成される場合は、入れ替えは行われません。 taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2); taskQueue.Enqueue(async ct => { ... }); taskQueue.Enqueue(async ct => { ... }); // このタスクが破棄される taskQueue.Enqueue(async ct => { ... }); PlayerLoop の指定 Queue を処理する PlayerLoop のタイミングを指定することができます。 以下のタイミング型が定義されています。 タイミング 説明 MewUnityEarlyUpdate Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 MewUnityFixedUpdate 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 MewUnityPreUpdate Update メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 MewUnityUpdate (既定値) 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。 MewUnityPreLateUpdate LateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 MewUnityPostLateUpdate フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 PlayerLoop のタイミングを指定するには、コンストラクタにタイミング型を指定します。 例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にキューの処理が遅延することを防くことができます。 var fixedUpdateTaskQueue = new TaskQueue();" + }, + "ja/TaskQueue/player-loop.html": { + "href": "ja/TaskQueue/player-loop.html", + "title": "PlayerLoop の指定 | MewCore", + "keywords": "PlayerLoop の指定 Queue を処理する PlayerLoop のタイミングを指定することができます。 以下のタイミング型が定義されています。 タイミング 説明 MewUnityEarlyUpdate Unityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。 MewUnityFixedUpdate 物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。 MewUnityPreUpdate Update メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。 MewUnityUpdate (既定値) 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。 MewUnityPreLateUpdate LateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。 MewUnityPostLateUpdate フレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。 PlayerLoop のタイミングを指定するには、コンストラクタにタイミング型を指定します。 例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にキューの処理が遅延することを防くことができます。 var fixedUpdateTaskQueue = new TaskQueue();" }, "ja/index.html": { "href": "ja/index.html", diff --git a/docs/ja/TaskInterval/index.html b/docs/ja/TaskInterval/index.html index 17cb777..5cd880a 100644 --- a/docs/ja/TaskInterval/index.html +++ b/docs/ja/TaskInterval/index.html @@ -169,49 +169,6 @@

使用する Timer の指定

.Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime) .Start(destroyCancellationToken); -

PlayerLoop の指定

-

タスクを処理する PlayerLoop のタイミングを指定することができます。 -以下のタイミング型が定義されています。

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
タイミング説明
MewUnityEarlyUpdateUnityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。
MewUnityFixedUpdate物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。
MewUnityPreUpdateUpdate メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。
MewUnityUpdate主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。
MewUnityPreLateUpdateLateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。
MewUnityPostLateUpdateフレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。
-

PlayerLoop のタイミングを指定するには、TaskIntervalに対してタイミング型を指定します。 -例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にも安定したゲーム時間でのタスク実行を行い遅延することを防くことができます。

-
TaskInterval<MewUnityFixedUpdate>
-    .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime)
-    .Start(destroyCancellationToken);
-
diff --git a/docs/ja/TaskInterval/player-loop.html b/docs/ja/TaskInterval/player-loop.html new file mode 100644 index 0000000..37ccc32 --- /dev/null +++ b/docs/ja/TaskInterval/player-loop.html @@ -0,0 +1,157 @@ + + + + + PlayerLoop の指定 | MewCore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ +
+
+
+
+
Table of Contents
+ +
+
+ +
+
+
+ +
+
+ + + +
+ +
+

PlayerLoop の指定

+ +

タスクを処理する PlayerLoop のタイミングを指定することができます。 +以下のタイミング型が定義されています。

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
タイミング説明
MewUnityEarlyUpdateUnityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。
MewUnityFixedUpdate物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。
MewUnityPreUpdateUpdate メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。
MewUnityUpdate主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。
MewUnityPreLateUpdateLateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。
MewUnityPostLateUpdateフレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。
+

PlayerLoop のタイミングを指定するには、TaskIntervalに対してタイミング型を指定します。 +例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にも安定したゲーム時間でのタスク実行を行い遅延することを防くことができます。

+
TaskInterval<MewUnityFixedUpdate>
+    .Create(1000 /* ms */, TestTaskAsync, IntervalTimerType.UnityUnscaledTime)
+    .Start(destroyCancellationToken);
+
+ +
+ +
+ Edit this page +
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ Made with docfx +
+
+
+ + diff --git a/docs/ja/TaskQueue/index.html b/docs/ja/TaskQueue/index.html index c66da3b..c8a67a0 100644 --- a/docs/ja/TaskQueue/index.html +++ b/docs/ja/TaskQueue/index.html @@ -86,26 +86,31 @@
Table of Contents

TaskQueue

-

TaskQueue は、Unity 開発における非同期処理を簡素化し、効率的に扱うためのライブラリです。このライブラリは、動的に変化する非同期関数の管理と、優先度に基づいた実行順序の決定を可能にします。

+

TaskQueue は Unity 開発における非同期関数の直列処理を行うためのライブラリです。 +キューに入力した順で非同期関数が実行されます。 +また、優先度付きキューの機能も備えており、重要なタスクを優先的に実行することができます。

主な特徴

-

動的な関数追加: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。

-

優先度に基づく実行管理: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。

-

直列処理と安全性: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。

-

シンプルな記述: TaskQueue は、非同期関数の実行を簡単に記述できるように設計されています。

+
    +
  • 動的な関数追加: ランタイムで非同期関数をタスクキューに追加することができます。これにより、変化する要件や状況に柔軟に対応可能です。
    • +
  • 優先度に基づく実行管理: 各非同期関数に優先度を設定し、重要なタスクを優先的に処理します。これにより、重要な処理の遅延を防ぎます。
    • +
  • 直列処理と安全性: 複数の非同期関数を順序立てて実行し、一つの関数が完了するまで次の関数の実行を待機します。これにより、UI 更新やゲームシーケンスの安全性が向上します。
    • +
  • キューの最大サイズ: キューに入力できるタスクの最大数を設定できます。これにより、キューにタスクが溜まりすぎることを防ぐことができます。
    • +
  • シンプルな記述: シンプルに記述できるように設計されています。
    • +

使用シナリオ

-

UIの動的更新: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。

-

ゲームイベントのシーケンシング: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。

-

TaskQueue を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。

-

コマンドパターンへの適応: 非同期処理を含めたコマンドパターンの実装に適しています。

-

UI イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。

+
    +
  • UIの動的更新: ゲーム内でのダイアログボックスやメニューの動的な表示・非表示をスムーズに制御する際に使用します。
    • +
  • ゲームイベントのシーケンシング: 物語進行やチュートリアルなど、順序立てられたイベントの管理に適しています。
    • +
  • TaskQueue を使用することで、Unity 開発における非同期処理の複雑さを軽減し、より効果的かつ効率的なコード記述を可能にします。
    • +
  • コマンドパターンへの適応: 非同期処理を含めたコマンドパターンの実装に適しています。
    • +
  • UI イベントのハンドリング: クリックなど UI の非同期イベントに対して並列実行を防ぐために使用します。
    • +

サンプルコード

class Sample : Monobehaviour
 {
     void Start()
     {
-        // TaskQueue のインスタンスを生成します。
         var taskQueue = new TaskQueue();
-        // TaskQueue の実行を開始します。
         // destroyCancellationToken を渡すことで
         // MonoBehaviour が破棄されたタイミングで自動的に処理を停止し Dispose されます。
         taskQueue.Start(destroyCancellationToken);
@@ -131,8 +136,25 @@ 
実行結果

優先度付きタスクの実行

Enqueue の第二引数に優先度を指定することで、優先度付きタスクを実行することができます。 -priority値が低いほど処理が優先されます。既定値は 0 です。

+priotiry値が小さい処理が優先されます。既定値は 0 です。

taskQueue.Enqueue(async ct => { ... }, priority: 1);
+taskQueue.Enqueue(async ct => { ... }, priority: 0); // このタスクが優先して処理される
+
+

キュー最大サイズの設定

+

TaskQueueLimitType.Discard

+

最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後に追加されたタスクが破棄されます。

+
taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2);
+taskQueue.Enqueue(async ct => { ... });
+taskQueue.Enqueue(async ct => { ... });
+taskQueue.Enqueue(async ct => { ... });　// このタスクが破棄される
+
+

TaskQueueLimitType.SwapLat

+

最大サイズ 2 のキューに対して以下のようにタスクを追加し、最大数を超えた場合、最後のタスクを入れ替えます。 +追加されるタスクより優先度が高いタスクでキューが構成される場合は、入れ替えは行われません。

+
taskQueue = new TaskQueue(TaskQueueLimitType.Discard, maxSize: 2);
+taskQueue.Enqueue(async ct => { ... });
+taskQueue.Enqueue(async ct => { ... });　// このタスクが破棄される
+taskQueue.Enqueue(async ct => { ... });　

PlayerLoop の指定

Queue を処理する PlayerLoop のタイミングを指定することができます。 diff --git a/docs/ja/TaskQueue/player-loop.html b/docs/ja/TaskQueue/player-loop.html new file mode 100644 index 0000000..107aaf3 --- /dev/null +++ b/docs/ja/TaskQueue/player-loop.html @@ -0,0 +1,155 @@ + + + + + PlayerLoop の指定 | MewCore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ +
+ +
+
+
+
+
Table of Contents
+ +
+
+ +
+
+
+ +
+
+ + + +
+ +
+

PlayerLoop の指定

+ +

Queue を処理する PlayerLoop のタイミングを指定することができます。 +以下のタイミング型が定義されています。

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
タイミング説明
MewUnityEarlyUpdateUnityのフレーム更新の最初の段階で呼ばれます。この時点で、最初のイベント処理や入力の更新が行われます。
MewUnityFixedUpdate物理演算の更新が行われるタイミングです。Unityエンジンにおける固定フレームレートでの処理に対応します。
MewUnityPreUpdateUpdate メソッドの前に実行される処理です。シーンの状態更新やアニメーションの更新などが含まれます。
MewUnityUpdate(既定値) 主にゲームロジックの更新に使用される、通常の Update メソッドのタイミングです。
MewUnityPreLateUpdateLateUpdate の前に実行される処理です。一部のカメラやアニメーションの後処理が行われる可能性があります。
MewUnityPostLateUpdateフレームの最後に実行される処理で、レンダリングの前準備やカメラの最終更新が含まれます。
+

PlayerLoop のタイミングを指定するには、コンストラクタにタイミング型を指定します。 +例えば MewUnityFixedUpdate を指定ることで、フレームスキップが発生した場合にキューの処理が遅延することを防くことができます。

+
var fixedUpdateTaskQueue = new TaskQueue<MewUnityFixedUpdate>();
+
+ +
+ +
+ Edit this page +
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ Made with docfx +
+
+
+ + diff --git a/docs/ja/toc.html b/docs/ja/toc.html index 3dd01c6..48d1b23 100644 --- a/docs/ja/toc.html +++ b/docs/ja/toc.html @@ -29,6 +29,9 @@
  • 例外のハンドリング
    • +
  • + PlayerLoop の指定 +
  • @@ -42,6 +45,9 @@
  • 例外のハンドリング
    • +
  • + PlayerLoop の指定 +
    • diff --git a/docs/ja/toc.json b/docs/ja/toc.json index dfbe539..24534cb 100644 --- a/docs/ja/toc.json +++ b/docs/ja/toc.json @@ -1,2 +1,2 @@ -{"items":[{"name":"インストール","href":"index.html","topicHref":"index.html"},{"name":"TaskQueue","items":[{"name":"イントロダクション","href":"TaskQueue/index.html","topicHref":"TaskQueue/index.html"},{"name":"特定のタスクの完了を待機する","href":"TaskQueue/awaitable.html","topicHref":"TaskQueue/awaitable.html"},{"name":"例外のハンドリング","href":"TaskQueue/exception.html","topicHref":"TaskQueue/exception.html"}]},{"name":"TaskInterval","items":[{"name":"イントロダクション","href":"TaskInterval/index.html","topicHref":"TaskInterval/index.html"},{"name":"例外のハンドリング","href":"TaskInterval/exception.html","topicHref":"TaskInterval/exception.html"}]}],"pdf":false} +{"items":[{"name":"インストール","href":"index.html","topicHref":"index.html"},{"name":"TaskQueue","items":[{"name":"イントロダクション","href":"TaskQueue/index.html","topicHref":"TaskQueue/index.html"},{"name":"特定のタスクの完了を待機する","href":"TaskQueue/awaitable.html","topicHref":"TaskQueue/awaitable.html"},{"name":"例外のハンドリング","href":"TaskQueue/exception.html","topicHref":"TaskQueue/exception.html"},{"name":"PlayerLoop の指定","href":"TaskQueue/player-loop.html","topicHref":"TaskQueue/player-loop.html"}]},{"name":"TaskInterval","items":[{"name":"イントロダクション","href":"TaskInterval/index.html","topicHref":"TaskInterval/index.html"},{"name":"例外のハンドリング","href":"TaskInterval/exception.html","topicHref":"TaskInterval/exception.html"},{"name":"PlayerLoop の指定","href":"TaskInterval/player-loop.html","topicHref":"TaskInterval/player-loop.html"}]}],"pdf":false} diff --git a/docs/manifest.json b/docs/manifest.json index 48bb032..3376aab 100644 --- a/docs/manifest.json +++ b/docs/manifest.json @@ -349,6 +349,16 @@ }, "version": "" }, + { + "type": "Conceptual", + "source_relative_path": "ja/TaskInterval/player-loop.md", + "output": { + ".html": { + "relative_path": "ja/TaskInterval/player-loop.html" + } + }, + "version": "" + }, { "type": "Conceptual", "source_relative_path": "ja/TaskQueue/awaitable.md", @@ -379,6 +389,16 @@ }, "version": "" }, + { + "type": "Conceptual", + "source_relative_path": "ja/TaskQueue/player-loop.md", + "output": { + ".html": { + "relative_path": "ja/TaskQueue/player-loop.html" + } + }, + "version": "" + }, { "type": "Conceptual", "source_relative_path": "ja/index.md",