はじめに

何番煎じなのかわかりませんが、過去にいろいろ解説した記事へのリンクをまとめる意味も込めて解説します。

UniRxとは

おすすめ資料

• UniRx入門シリーズ 目次
• UniRx オペレータ一覧
• UniRx オペレータ逆引き
• ReactiveCommand/AsyncReactiveCommandについて
• ObserverパターンからはじめるUniRx
• Observable の非同期処理への活用

概要

• UniRx - GitHub

UniRxとは、Reactive ExtensionsをUnity向けの実装したC#ライブラリです。
かなり昔のバージョンのUnityでも扱うことができます。
導入することで、Unityにおいて次のような処理の実装が簡単になります。

• 非同期処理
  • 何らかの処理の完了を待ち受けて次の処理を行うような処理の管理
  • エラーハンドリングやリトライ処理の簡略化
  • 実行結果のハンドリングやキャッシュ
  • 実行スレッドの柔軟な切り替え

// data.txtをスレッドプール上で読み込み、メインスレッド上で表示する
Observable
    .Start(() => File.ReadAllText("data.txt"))
    .ObserveOnMainThread()
    .Subscribe(x => Debug.Log(x));

• イベント処理
  • 処理のトリガーと実際にハンドリングする場所を分離して記述できる
  • イベントメッセージの加工や合成
  • 実行スレッドの柔軟な切り替え

void Start()
{
    // Jumpボタンが押されたらログに出す
    // 1度発動したら1秒間は何もしない
    this.UpdateAsObservable()
        .Where(_ => Input.GetButtonDown("Jump"))
        .ThrottleFirst(TimeSpan.FromSeconds(1000))
        .Subscribe(_ => Debug.Log("Jump!!"));
}

UniRxは「非同期処理」と「イベント処理」の2つを扱うことができるライブラリです。
特に「時間」の扱いに長けており、Unityにおける「フレームをまたいだ処理」などの実装が簡単になります。

なお、UniRxが提供するこれら便利な機能は正式には「Observable」と呼ばれています。

Observable

ObservableとはUniRxが提供する、「メッセージを通知のための機構およびそのオブジェクト」の指します。
型としてはIObservable<T>で表現されます。

// 実行結果は IObservable<T> でハンドリングする
private IObservable<string> ReadFileObservable(string path)
{
    return Observable
        .Start(() => File.ReadAllText(path))
        .ObserveOnMainThread();
}

Observableの仕組み、およびSchedulerやOperatorの概念について詳しく知りたい方は次の資料を御覧ください。

• ObserverパターンからはじめるUniRx

Operator一覧

UniRxでもっとも便利な機能がこのOperatorです。
OperatorはObservableに対するさまざまな処理を提供してくれます。
そのためこのOperatorを組み合わせるだけで、だいたいの処理の実装が完了してしまいます。

• UniRx オペレータ一覧
• UniRx オペレータ逆引き

UniTaskとは

おすすめ資料

• Deep Dive async/await in Unity with UniTask(UniRx.Async)
• さては非同期だなオメー！async/await完全に理解しよう
• async/await のしくみ
• 実践! ライブコーディングで覚えるasync/await
• UniTask入門
• 【Unity開発者向け】「SynchronizationContext」と「Taskのawait」
• UniTask機能紹介
• UniRxとUniTask 相互変換の変わったパターン紹介

概要

• UniTask - GitHub

UniTaskとは、C#の標準TaskおよびTaskSchedulerをUnity向けに最適化して実装したC#ライブラリです。
UniTaskは標準Taskと比べてパフォーマンスが出るため、非同期処理を扱う場合は是非導入してほしいライブラリです。ただし導入時はUnity 2018.3以降を推奨。

UniTaskを導入することで、次のようなメリットがあります。

• Unity向けに最適化されたTaskおよびTaskSchedulerが利用できる
  • ValueTaskのUnity向け実装
  • UnityのPlayerLoopを用いたSchedule管理
  • SynchronizationContextに依存しない

async void Start()
{
    var path = "data.txt";

    // UniTaskのawaitは基本的にメインスレッドに戻る
    var result = await LoadFileAsync(path);

    Debug.Log(result);
}

private UniTask<string> LoadFileAsync(string path)
{
    return UniTask.Run(() => File.ReadAllText(path));
}

• さまざまなオブジェクトへのAwaiter実装の提供
  • コルーチンをasync/awaitに置き換える可能に
  • yield returnの代わりにawaitで非同期処理の待機ができるようになる

private void Start()
{
    JumpAsync(this.GetCancellationTokenOnDestroy()).Forget();
}

/// <summary>
/// ボタンが押されたらジャンプする
/// </summary>
private async UniTaskVoid JumpAsync(CancellationToken token)
{
    var rigidBody = GetComponent<Rigidbody>();

    while (!token.IsCancellationRequested)
    {
        // ボタンが押されるのをUpdateタイミングで待つ
        await UniTask.WaitUntil(() => Input.GetButtonDown("Jump"),
            PlayerLoopTiming.Update,
            cancellationToken: token);

        // 押されたらFixedUpdateのタイミングでジャンプする
        await UniTask.Yield(PlayerLoopTiming.FixedUpdate);
        rigidBody.AddForce(Vector3.up, ForceMode.Impulse);

        // 1秒待って繰り返す
        await UniTask.Delay(1000, cancellationToken: token);
    }
}

UniTaskは「非同期処理」に特化したライブラリです。
導入することでほぼすべてのコルーチンをasync/awaitに置換することができます。

標準Taskとの比較

UniTaskはC# 7.0で追加された、ValueTaskライクに作られています。
そのためasync/await時、処理が同期で完了する場合においてはヒープアロケーションが発生しないという特徴があります。また、UniTaskは実行コンテキストの管理にSynchronizationContextではなくUnity Player Loopを用いるように作られています。

そのため、標準のTask/ValueTaskと比較してUniTaskの方がよりUnityではパフォーマンスを出すことができるようになっています。

	Task	UniTask
機能	Unityでは不要な機能が多い	Unityで活用できる機能のみ実装
オブジェクトサイズ	大きい	小さい
実行コンテキストの管理	TaskScheduler & SynchronizationContext	UnityのPlayerLoop
必要なC# version	C# 5.0以上	C# 7.0以上
TaskTracker	無	UnityEditor上で確認可能
メモリアロケーション	常にヒープを確保する	同期処理で完了する場合はヒープを確保しない

UniRxとUniTask、それぞれの使い分け

「UniTaskとUniRxの非同期処理の使い分けの基準は何か」という疑問を持つ人もいるでしょう。
それぞれの使い分けについて説明します。

UniTaskを使うべき場合

非同期処理の結果通知が「1回」で済む場合

結果通知が1回である、つまりは単発で完了する普通の非同期処理の場合です。
こちらはUniTask（とasync/await）を使うべきです。

理由として次が挙げられます。

• 同期処理と見た目がほぼ変わらないコードを書ける
• 単発で済む非同期処理に対して、Observable自体がオーバースペック気味

async/awaitを使うと非同期処理をほぼ同期処理と変わらない見た目で記述することができます。
そのため同期処理で書いていた部分をあとから非同期化する、またはその逆といった対応も比較的楽にすみます。

Observableの場合、処理が1回で済む非同期処理に対してはかなりオーバースペックになってしまいます。まず「メッセージの発行元は何か」「メッセージは何回発行されるのか」を常に意識しなくてはいけません。
さらにはHotやColdといった性質も考えなくてはならず、UniTaskほど気軽に扱えません。

また、Observableを用いた非同期処理は同期処理とまったく異なる記述法になってしまいます。
そのため、あとから処理内容を同期処理へ直そうと思ったときに、Observableを使っている場所ほぼすべてを新しく書き直す必要が出てきてしまいます。

処理を手続き的に記述したい場合

Observableでは非同期処理をOperatorを用いて処理を宣言的に記述することができました。
これは処理の内容がOperatorの表現範囲で済む限りにおいては便利ではあります。
ですが実際の開発においてはそう簡単に行きません。Operatorではどうしても表現しきれない処理が出てきた場合、これを手続き的に書き下す必要があります。

また、Observableは「処理の条件分岐ができない」という欠点があります。
メッセージ内容に応じてその場で実行する処理をごっそり切り替えるといったことができません。
（処理内容ごとに新しいObservableを定義しなくてはいけないため無駄が多い）

UniTask（とasync/await）であれば、処理をほぼ同期処理と変わらずに手続き的に記述することができます。
そのため、要求どおりの仕様を満たした処理をObservableとOperatorで記述するよりも、よりわかりやすい簡単に実装することができます。

UniRx（Observable）を使うべき場合

非同期処理の結果が複数個になる場合

ここでいう複数個の結果とは、UniTask<IEnumerable<T>>で済むような場合の話ではありません。非同期処理そのものが継続的に実行され、結果が断続的に発行されるようなシチュエーションを想定しています。
（たとえばディレクトリの中身をまとめて読み込んで、読み込みが先に終わったファイルから処理を次々に行うなど）

このような非同期処理はUniTaskでは表現が不可能なため、IObservable<T>を使うことになります。

補足 IAsyncEnumerable<T>とIObservable<T>の違い

C# 8.0でIAsyncEnumerable<T>というものが追加されました。名前のとおり「非同期ストリーム」です。IObservable<T>と役割が被ってそうですが、そこは明確に異なります。

• IObservable<T> : 非同期処理が常に動いておりその結果がPUSHで通知される
• IAsyncEnumerable<T> : 結果をPULLしたときに1つ非同期処理が走る

非同期処理を裏で動かしてその結果がPUSH通知されるのを待つならIObservable<T>を使う。
await foreachと組み合わせて、逐次処理をしていくならIAsyncEnumerable<T>を使う。

といった使い分けが今後は必要になってくるでしょう。
（まだUnityはC# 8.0に対応していないので、もう少しあとの話ですが）

イベント処理を行う場合

C#のevent構文や、UnityEventの代替としてUniRxは利用することができます。
またUpdate()やFixedUpdate()をObservableに変換したり、uGUIと組み合わせて使うと表現力が広がりかなり便利に使うことができます。

（そもそも「イベント処理」=「値が複数回発行される非同期処理」とほぼ同義なので、同じことを2回説明しているだけですが）

Unityで動くC#バージョンが低い場合

古のUnityでは対応しているC#バージョンが低く、async/awaitすら使えない場合があります。
特に長期運用しているプロジェクトですと未だにUnity 5系を使っているなんてこともあるでしょう。

この場合はUniTaskを用いることはできないので、UniRxが非同期処理における唯一の選択肢となります。
コルーチンとObservableを併用するなどするとよいでしょう。

• UniRx入門 その5 -コルーチンとの併用-

相互変換

なお、ObservableとUniTaskはそれぞれ相互変換が可能です。
そのためどちらか片方にこだわる必要はなく、場面に応じて変換して使い分けるとよいでしょう。

UniTask -> UniRx

キャンセルを考えない場合

UniTask.ToObservable()で変換できます。
この場合、Schedulerは自動的にMainThreadScheduler指定となります。

using UniRx;
using UniRx.Async;
using UnityEngine;
using UnityEngine.Networking;

public class UniTaskToUniRx : MonoBehaviour
{
    void Start()
    {
        // UniTask<string>
        var uniTask = LoadTextAsync("https://github.com/");

        // UniTask<string> -> IObservable<string>
        // UniTaskのキャンセルを考えないならこれだけでOK
        uniTask.ToObservable().Subscribe(Debug.Log);
    }

    /// <summary>
    /// Textを指定のパスから読み込む
    /// </summary>
    private async UniTask<string> LoadTextAsync(string path)
    {
        var uwr = UnityWebRequest.Get(path);
        await uwr.SendWebRequest();
        return uwr.downloadHandler.text;
    }
}

キャンセルを考える場合

一発で変換するメソッドはありません。
そのため次のような方法でがんばるしかないです。

• UniTaskをCancellationTokenを指定しながらToObservableするメモ

UniRx -> UniTask

IObservable -> UniTask

ToUniTask()を使うことでUniTaskに変換できます。
ただしデフォルトではOnCompletedメッセージが発行されるまで待ち受けてしまいます。
次に発行される1メッセージだけを待ち受けたい場合は、useFirstValueオプションをつけましょう。

private async UniTaskVoid CheckEnemyAsync(CancellationToken cancellationToken)
{
    // 新たに生成されたEnemyが通知されるObservableがあったとして
    IObservable<Enemy> enemyObservable = _enemySpawner.OnEnemySpawned;

    while (!cancellationToken.IsCancellationRequested)
    {
        // ToUniTask(useFirstValue: true) でUniTask化してawaitできる
        var enemy = await enemyObservable
            .ToUniTask(cancellationToken, useFirstValue: true);

        Debug.Log(enemy.Name);
    }
}

IReadonlyReactivePropertyのawait

正確にいえばUniTask変換ではないですが、どうせasync/awaitとセットで使うので解説します。
IReadonlyReactiveProperty<T>はawaitすることで、次のメッセージ発行を待ち受けることができます。

using System.Threading;
using UniRx;
using UniRx.Async;
using UniRx.Async.Triggers;
using UnityEngine;

public class ReactivePropertyAwait : MonoBehaviour
{
    // なにかのステート
    private enum GameState
    {
        Ready,
        Battle,
        Result
    }

    // ステート管理するReactiveProperty
    private ReactiveProperty<GameState> _currentGameState
        = new ReactiveProperty<GameState>();

    private void Start()
    {
        StateChangedAsync(this.GetCancellationTokenOnDestroy()).Forget();
    }

    /// <summary>
    /// ステート遷移するたびに処理を走らせる
    /// </summary>
    private async UniTaskVoid StateChangedAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            // ステート遷移を待つ
            var next = await _currentGameState;

            // 遷移先に合わせて処理をする
            switch (next)
            {
                case GameState.Ready:
                    // Do something...
                    break;
                case GameState.Battle:
                    // Do something...
                    break;
                case GameState.Result:
                    // Do something...
                    break;
            }
        }
    }
}

その他、変わった変換の例

その他の変わった変換パターンについては別記事にまとめました。

• UniRxとUniTask 相互変換の変わったパターン紹介

まとめ

UniRxとUniTaskはUnityでC#を触るならぜひとも導入してほしいライブラリです。
入れて絶対に損はしない、むしろ無いと困るくらいには便利なものなので使い方を覚えて活用できるようになるとよいでしょう。

また、現在UniRxとUniTaskの書籍の執筆を行っています。全体の執筆が概ね終わり、現在はレビューフェーズに入っています。発売されたらぜひよろしくおねがいします。

問題

フレーム内のなるべく遅いタイミングで、何か処理をしたい。普通なら、 LateUpdate() で十分だが、諸々の事情により OnGUI() よりも遅いタイミングが必要になった。

そこで実行順に関する公式ドキュメント(Order of Execution for Event Functions)を確認したところ良さげなタイミングを見つけたので、 WaitForEndOfFrame() を利用して強引に作ってみた。

endofframetest.cs

public class endofframetest : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(StartEndOfFrame());
        Debug.Log($"Start():{Time.frameCount}");
    }
    IEnumerator StartEndOfFrame()
    {
        while (true)
        {
            // Wait until all rendering + UI is done.
            yield return new WaitForEndOfFrame();
            OnEndOfFrame();
        }
    }

    private void FixedUpdate()
    {
        Debug.Log($"FixedUpdate():{Time.frameCount}");
    }
    void Update()
    {
        Debug.Log($"Update():{Time.frameCount}");
    }
    private void LateUpdate()
    {
        Debug.Log($"LateUpdate():{Time.frameCount}");
    }
    private void OnGUI()
    {
        Debug.Log($"OnGUI():{Time.frameCount}");
    }
    private void OnEndOfFrame()
    {
        Debug.Log($"OnEndOfFrame():{Time.frameCount}");
    }
}

Console.

Start():1

FixedUpdate():1

Update():1

LateUpdate():1

FixedUpdate():2

Update():2

LateUpdate():2

OnGUI():2

OnGUI():2

OnEndOfFrame():2

結果

Start()のタイミングを1フレーム目としたとして２フレーム目からしか呼ばれないので、その点は注意する必要があるが概ね問題なく利用できた。

ちなみに、、、OnGUI()も２フレーム目からしか呼ばれないようだ(確認したのはUnity2020.1α)。

概要

コルーチンとは

使い所

参考

これはUnity Advent Calender 2019の24日目の記事です。

3Dキャラクターをミラー処理するPlayableを作りたい

2D格闘ゲームや横スクロールアクションゲームでキャラクターや背景を3Dで表現した、いわゆる2.5Dゲームにおいて、キャラクターをミラーリング（左右反転）処理したいケースがあります。

なぜミラーリングが必要なのか？それはキャラクターは常に画面側を向いててほしいからです。
普通の3Dキャラクターでは右向きで画面に向くよう調整しても、左向きだと背中向けることになってしまい、こちら側を見てくれません。

ミラーリング処理をすることで、左向きでも右向きでも常にこちら向いてくれるようになるわけです。

UnityのMecanimには既にHumanoidに限りMirror機能がありますが、それを使わずにPlayables APIを使って自前で実装します。

結果

左右反転した動きをする3Dキャラクターを表示できました。
が、、よく見ると顔パーツの反転ができてません。
顔の中身をテクスチャで描いているためです。こちらの問題に対応するにXスケールを反転する（ポリゴンが反転するため、シェーダー側の対応も必要）するか、左右反転したテクスチャを用意しておいて、それに切り替えるかで対応する必要があります。
目をボーンで制御している昨今の３Dキャラクターであれば得に問題ないでしょう。

そもそも完全な左右対称の結果を得るにはシンメトリー（左右対称）なキャラクターに限定している話でもあります。
アシンメトリー（左右非対称）なキャラクターの場合、ある程度なら反転結果の差異を許容してもよいですが、場合によっては難しいケース（腕の長さが違う等）もあります。
今記事ではそこまでは触れないでおきます。

今回作成したサンプルプロジェクトをGithubで公開してます。合わせてどうぞ。
https://github.com/you-ri/MirrorAnimationPlayable

なぜMecanim(AnimatorController)のMirrorを使わず自前で実装するのか？

Mecanimには既にMirror機能があります。なのになぜ自前で用意するのでしょうか？

自身のプロジェクトは当初普通にAnimatorControllerを使っていましたが、2018.2あたりでAnimatorControllerのPlayable版、AnimatorControllerPlayableに移行しました。
ところがUnity2019.2にバージョンアップした際、キャラクターのアニメーションが動かなくなるバグを踏んでしまいました。
AnimatorControllerOverrideを使ってランタイム中に書き換えるアプローチで大量のAnimationClipを処理していたのですが、これが機能しなくなったのです。

当然バグ報告しましたが、音沙汰なし。。。これは、、、仕様ということか？
しびれを切らして、自前で大量のAnimationClipを捌き、ミラーを再現する機能をPlayables APIを使って開発する必要がでてきたというわけです。

HumanoidのミラーをAnimationScriptPlayabeで再現する

まずググったところ以下のスレッドがヒットしました。

Playables API - Mirroring Clips and DirectorUpdateMode.Manual

残念なのことにUnityの中の人も途中で投げだしてしまって解決には至っていません。
Muscleの情報から顔や体のロール(RollLeftRight)とヨー(LeftRight)を反転、さらに左右の手、足、指、目などは交換するとで、ミラーした結果が得られるのは理解できるのですが。なぜうまく行かないのか。。。

少し悩んだ末、ルートの回転ミラー計算を見直したところ、左右反転後の姿勢を作り出せることに成功しました。
ついでにIKのミラーにも対応しておきました。

        public static void MirrorPose (this AnimationHumanStream humanStream)
        {
            humanStream.bodyLocalPosition = Mirrored (humanStream.bodyLocalPosition);
            humanStream.bodyLocalRotation = Mirrored (humanStream.bodyLocalRotation);


            // mirror body
            for (int i = 0; i < (int)BodyDof.LastBodyDof; i++) {
                humanStream.MultMuscle (new MuscleHandle ((BodyDof)i), BodyDoFMirror[i]);
            }

            // mirror head
            for (int i = 0; i < (int)HeadDof.LastHeadDof; i++) {
                humanStream.MultMuscle (new MuscleHandle ((HeadDof)i), HeadDoFMirror[i]);
            }

            // swap arms
            for (int i = 0; i < (int)ArmDof.LastArmDof; i++) {
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftArm, (ArmDof)i),
                    new MuscleHandle (HumanPartDof.RightArm, (ArmDof)i));
            }

            // swap legs
            for (int i = 0; i < (int)LegDof.LastLegDof; i++) {
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftLeg, (LegDof)i),
                    new MuscleHandle (HumanPartDof.RightLeg, (LegDof)i));
            }

            // swap fingers
            for (int i = 0; i < (int)FingerDof.LastFingerDof; i++) {
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftThumb, (FingerDof)i),
                    new MuscleHandle (HumanPartDof.RightThumb, (FingerDof)i));
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftIndex, (FingerDof)i),
                    new MuscleHandle (HumanPartDof.RightIndex, (FingerDof)i));
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftMiddle, (FingerDof)i),
                    new MuscleHandle (HumanPartDof.RightMiddle, (FingerDof)i));
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftRing, (FingerDof)i),
                    new MuscleHandle (HumanPartDof.RightRing, (FingerDof)i));
                humanStream.SwapMuscles (
                    new MuscleHandle (HumanPartDof.LeftLittle, (FingerDof)i),
                    new MuscleHandle (HumanPartDof.RightLittle, (FingerDof)i));
            }


            // swap ik
            Vector3[] goalPositions = new Vector3[4];
            Quaternion[] goalRotations = new Quaternion[4];
            float[] goalWeightPositons = new float[4];
            float[] goalWeightRotations = new float[4];
            Vector3[] hintPositions = new Vector3[4];
            float[] hintWeightPositions = new float[4];
            for (int i = 0; i < 4; i++) {
                goalPositions[i] = humanStream.GetGoalLocalPosition (AvatarIKGoal.LeftFoot + i);
                goalRotations[i] = humanStream.GetGoalLocalRotation (AvatarIKGoal.LeftFoot + i);
                goalWeightPositons[i] = humanStream.GetGoalWeightPosition (AvatarIKGoal.LeftFoot + i);
                goalWeightRotations[i] = humanStream.GetGoalWeightRotation (AvatarIKGoal.LeftFoot + i);
                hintPositions[i] = humanStream.GetHintPosition (AvatarIKHint.LeftKnee + i);
                hintWeightPositions[i] = humanStream.GetHintWeightPosition (AvatarIKHint.LeftKnee + i);
            }
            for (int i = 0; i < 4; i++) {
                int j = (i + 1) % 2 + (i / 2) * 2;                  // make [1, 0, 3, 2]
                humanStream.SetGoalLocalPosition (AvatarIKGoal.LeftFoot + i, Mirrored(goalPositions[j]));
                humanStream.SetGoalLocalRotation (AvatarIKGoal.LeftFoot + i, Mirrored(goalRotations[j]));
                humanStream.SetGoalWeightPosition (AvatarIKGoal.LeftFoot + i, goalWeightPositons[j]);
                humanStream.SetGoalWeightRotation (AvatarIKGoal.LeftFoot + i, goalWeightRotations[j]);
                humanStream.SetHintPosition (AvatarIKHint.LeftKnee + i, hintPositions[j]);
                humanStream.SetHintWeightPosition (AvatarIKHint.LeftKnee + i, hintWeightPositions[j]);
            }
        }

        public static Vector3 Mirrored (Vector3 value)
        {
            return new Vector3 (-value.x, value.y, value.z);
        }

        public static Quaternion Mirrored (Quaternion value)
        {
            return Quaternion.Euler (value.eulerAngles.x, -value.eulerAngles.y, -value.eulerAngles.z);
        }

しかし、これだけでは不完全です。武器もミラーリングしないと実際のゲームでは使えません。

武器のミラーに対応する

Humanoidのミラー対応できました。次は武器、追加ボーンのミラー対応をします。

武器のミラーリングは複製した武器をもう片方の手にもたせて、表示、非表示で表現する方法が最も簡単ですが、武器オブジェクトが複製されているので、更新も２重に適応したりする必要があったり扱いが煩雑になりそうです。

今回はミラーリング時には片方のボーンに固定することで擬似的に親子関係が変わったように表現します。
武器の親ボーンをミラーリングした後に、武器をそのボーン下のトランスフォームに固定します。

ヒエラルキーのセットアップ

開発中のゲームのモデルを例に説明したいと思います。
まずミラーリング対応するためのヒエラルキーをセットアップします。

アニメーション制作時に向く方向は統一しておきます。今回weapon_Rにアニメーション情報が入っており、常にAnimationClipによって更新されます。
それの反転姿勢を保持するためのweapon_Lを作り、その子にミラー後の表示位置を確認するための武器としてjanis_weapon_mirrorをアタッチし、に左右対称になるように調整しておきます。
janis_weapon_mirrorはミラー後の武器のアタリとして用意するだけで実際は表示しません。無効化しておきます。

追加トランスフォーム分をミラー処理する

武器の親トランスフォームをミラーリングしないといけません。

weapon_Rのミラーリング後した姿勢をweapon_Lへ反映します。

Humanoidのミラーリング処理する前に武器ボーンをミラーリングします。
ミラーリングしたいボーンをキャラクターの座標系（ルート座標系）に変換した後、XY平面でミラー化してその結果を片方のボーンに設定します。

    public struct MirroringPlayableJob : IAnimationJob, IDisposable
    {

        public struct MirroringConstrant
        {
            public TransformStreamHandle driven;
            public TransformStreamHandle source;
        }

        public struct MirroringPosture
        {
            public TransformStreamHandle source;
            public TransformStreamHandle driven;
        }

        public bool debug;
        public bool isMirror;

        public TransformStreamHandle root;

        public NativeArray<MirroringPosture> mirroringTransforms;
        public NativeArray<MirroringConstrant> mirroringConstrants;

        public void ProcessRootMotion (AnimationStream stream) { }

        public void ProcessAnimation (AnimationStream stream)
        {
            Vector3 rootPosition;
            Quaternion rootRotation;
            root.GetGlobalTR (stream, out rootPosition, out rootRotation);
            var rootTx = new AffineTransform (rootPosition, rootRotation);

            var mirroredTransforms = new NativeArray<AffineTransform> (mirroringTransforms.Length, Allocator.Temp);

            // 追加トランスフォームのミラーリング計算
            if (isMirror) {
                for (int i = 0; i < mirroringTransforms.Length; i++) {

                    if (!mirroringTransforms[i].source.IsValid (stream)) continue;
                    if (!mirroringTransforms[i].driven.IsValid (stream)) continue;

                    Vector3 position;
                    Quaternion rotation;
                    mirroringTransforms[i].source.GetGlobalTR (stream, out position, out rotation);

                    var drivenTx = new AffineTransform (position, rotation);
                    drivenTx = rootTx.Inverse() * drivenTx;
                    drivenTx = AnimationStreamMirrorExtensions.Mirrored (drivenTx);
                    drivenTx = rootTx * drivenTx;
                    mirroredTransforms[i] = drivenTx;
                }
            }


            // Humanoid ミラーリング
            ~~ 省略 ~~

            // 追加トランスフォームのミラーリング適用
            if (isMirror) {
                for (int i = 0; i < mirroringTransforms.Length; i++) {

                    if (!mirroringTransforms[i].source.IsValid (stream)) continue;
                    if (!mirroringTransforms[i].driven.IsValid (stream)) continue;

                    mirroringTransforms[i].driven.SetGlobalTR (stream, mirroredTransforms[i].position, mirroredTransforms[i].rotation, false);
                }
            }

            // 追加トランスフォームのミラーリング拘束
            ~~ 省略 ~~
        }
    }

ミラー時にペアレントを切り替える

ミラー後のトランスフォームに武器を拘束して親子関係を切り替えたように見せます。

やり方は単純です。
この段階では janis_weapon_mirror の親トランスフォームのweapon_Lにはミラー後の姿勢になっているのでjanis_weapon_mirrorの姿勢をjanis_weaponにコピーするだけで、あたかも親トランスフォームがweapon_Lに切り替わったかのように見せることができます。

        public void ProcessAnimation (AnimationStream stream)
        {
            // Humanoid のミラーリング
            ~~ 省略 ~~

            // 追加トランスフォームのミラーリングの適用
            ~~ 省略 ~~

            // ミラーリングしたトランスフォームへのコンストレント
            if (isMirror) {
                for (int i = 0; i < mirroringConstrants.Length; i++) {

                    if (!mirroringConstrants[i].source.IsValid (stream)) continue;
                    if (!mirroringConstrants[i].driven.IsValid (stream)) continue;

                    Vector3 position;
                    Quaternion rotation;
                    mirroringConstrants[i].source.GetGlobalTR (stream, out position, out rotation);
                    mirroringConstrants[i].driven.SetGlobalTR (stream, position, rotation, false);
                }
            }
        }

あとはこれらのコードをPlayableGraphに登録するためのコンポーネントを作成すればおｋです。

それの詳細についてはここでは言及しません。サンプルプロジェクトの
CustomAnimation.csを参照ください。

まとめ

これで3Dキャラクターを使って2Dゲーム的な表現ができるようになった！といいたいところですが、画角があるため立ち位置によって見え方が変化してしまう問題が残っています。

これを解決するにはキャラクターやそれに付随するエフェクトなどは画角を抑えて描画する必要があります。
それはまた別の機会があれば記事にしたいと思います。

3Dキャラクターを使うことで開発中もデザインを後から修正することが楽になりますし、ランタイムで入れ替えることも可能になります。
3Dくささを打ち消すのが大変だったりしますが、魅力的なキャラクターが活躍する2.5Dゲームが増えればいいな～と思っています。

コツコツとゲーム作ってます。
対戦格闘アクション http://extrival.com

参考

• Playables API - Mirroring Clips and DirectorUpdateMode.Manual
• Animation C# Jobs
• Unity 2019.1 の Animation Rigging プレビューパッケージの概要
• 【Unity】AnimationControllerを用意せずAnimatorによるアニメーションを使う

1. はじめに

Unityのゲーム内で取得したデータをcsvに書き出す方法についての記事を書きます。

具体的には、2つのGameObjectの操作記録をcsvに時系列順で書き出すスクリプトを作成します。

2. 準備

2.1. 用意するGameObject

用意するGameObjectは3つです。

• F … 赤色のGameObject
• J … 水色のGameObject
• SaveCsv … EmptyGameObject

2.2. 用意するスクリプト

用意するはスクリプトも3つです。

• SampleFScript … F用のスクリプト
• SampleJScript … J用のスクリプト
• SampleSaveCsvScript … SaveCsv用のスクリプト

3. スクリプトに記述

3.1. SampleSaveCsvScripのコードの解説

まずは、csvに保存するためのコードをSampleSaveCsvScripに記述します。

3.1.1. void Start()

引用元サイト①で詳しく解説されています。
ざっくりとした説明をすると、新しくcsvファイルを作成して、{}の中の要素分csvに追記をするコードです。

3.1.2. public void SaveData(string txt1, string txt2, string txt3)

「s1」で記述したヘッダーの数分「string txt」を用意してください。
「public」をつけることで他のスクリプトでも「SaveData(～)」が使用できるようになります。
その他については、上記と同じです。

3.1.2. void Update()

Enterキーが押されたらcsvへの書き込みを終了するコードを記述しています。

SampleSaveCsvScrip

using System.IO;
using System.Text;

public class SampleSaveCsvScript : MonoBehaviour
{
    private StreamWriter sw;

    void Start()
    {
        sw = new StreamWriter(@"SaveData.csv", true, Encoding.GetEncoding("Shift_JIS"));
        string[] s1 = { "F", "J", "time" };
        string s2 = string.Join(",", s1);
        sw.WriteLine(s2);
    }

    public void SaveData(string txt1, string txt2, string txt3)
    {
        string[] s1 = { txt1, txt2, txt3 };
        string s2 = string.Join(",", s1);
        sw.WriteLine(s2);
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Return))
        {
            sw.Close();
        }

    }
}

3.2. SampleFScriptのコードの解説

SampleFScriptには、Fキーを検出するコードを記述します。

3.2.1. void Start()

引用元サイト②で詳しく解説されています。
ざっくりとした説明をすると、他のスクリプトを参照するコードを記述しています。

3.2.2. void Update()

Fキーが押されたら、csvに「F」と「いつ押されたか」という情報が書き加えられます。

SampleFScrip

using UnityEngine;
using System.IO;

public class SampleFScript : MonoBehaviour
{
    private float time;
    private StreamWriter sw;

    GameObject SaveCsv;
    SampleSaveCsvScript SampleSaveCsvScript;

    void Start()
    {
        SaveCsv = GameObject.Find("SaveCsv");
        SampleSaveCsvScript = SaveCsv.GetComponent<SampleSaveCsvScript>();
    }

    void Update()
    {
        time += Time.deltaTime;

        if (Input.GetKeyDown(KeyCode.F))
        {
            SampleSaveCsvScript.SaveData("F", " ", time.ToString());
        }
    }
}

3.3. SampleJScriptのコードの解説

SampleJScriptには、Jキーを検出するコードを記述します。

3.3.1. void Start()

上記と同じです。

3.2.2. void Update()

Jキーが押されたら、csvに「J」と「いつ押されたか」という情報が書き加えられます。

SampleJScrip

using UnityEngine;
using System.IO;

public class SampleFScript : MonoBehaviour
{
    private float time;
    private StreamWriter sw;

    GameObject SaveCsv;
    SampleSaveCsvScript SampleSaveCsvScript;

    void Start()
    {
        SaveCsv = GameObject.Find("SaveCsv");
        SampleSaveCsvScript = SaveCsv.GetComponent<SampleSaveCsvScript>();
    }

    void Update()
    {
        time += Time.deltaTime;

        if (Input.GetKeyDown(KeyCode.J))
        {
            SampleSaveCsvScript.SaveData(" ", "J", time.ToString());
        }
    }
}

4. 確認

実際にゲームを動かして確認をしてみます(ここは省略)。

すると、下記のようなcsvが出てきます。

「F」や「J」そして「いつ押されたか」という情報がきちんと書き出されていることが確認できると思います。

5. 最後に

Unityのゲーム内で取得したデータをcsvに書き出す方法について書いてみましたが、いかかだったでしょうか。
分かりづらい点や間違っている点があれば、ご指摘いただけると幸いです。

参考URL

① Unity 2D] データを保存する(外部ファイルCSV)
https://high-programmer.com/2017/12/10/unity-savedata-otherfile/

② [Unity]他のオブジェクトについているスクリプトの変数を参照したり関数を実行したりする。
https://qiita.com/tsukasa_wear_parker/items/09d4bcc5af3556b9bb3a

この記事は Akatsuki Advent Calendar 2019 23日目の記事です。
前日は @ShaderError さんによる Unityでシェーダー描いてみたい でした。
アカツキ人事がハートドリブンに書く Advent Calendar 2019 もあるのでそちらもぜひ。

はじめに

以前に仕事でCircleCIを使ってUnityのAndroidとiOSビルドを行なっていたのでその事について書こうかなと思っていたのですが、最近GitHub Actionsという新機能がGitHubで公開されました。
これがいい感じにCircleCIでUnityビルドをしていた際に起きていた問題を解決していたので、試験的に試してみたまとめが本記事になります。

環境

GitHub Actions 12/23時点のワークフロー構文
Unity 2019.3.0f1
MacBook Pro (self-hostedで利用するマシン)

GitHub Actionsとは

GitHubによるCI/CDツールです。
詳しいことは GitHub Actions Documentation に書いてありますが、JenkinsやCircleCIなどに替わる新しいツールとなるのか(個人的に)気になるサービスです。

GitHub Actions を導入する

前提：UnityProjectのリポジトリがGitHubに存在する状態であること
利用想定：self-hostedを使ってローカルにあるマシンをGitHub Actionsで利用する
前提の状態にするまでの解説は行いませんので、各自作業を行なってください。

GitHubのリポジトリの Setting -> Actions を選択して
Actions permissionsもEnable local and third party Actions for this repositoryに変更してください
その後にSelf-hosted runnersのAdd runner を選択

そうするとrunnerを追加するためのCLIのコマンドが表示されます。
各コマンドを順に実行してください。
実行した後にGitHubのページを再読み込みをするとSelf-hosted runnersにCLIコマンドを実行したPCが表示されていると思います。
これでGitHub Actionsでself-hostedが使えるようになりました。

その後にGitHubのActionsタブにあるSimple workflowを使って動作テストをしてみます。
runs-onをself-hostedにするのを忘れないでください。
変更が完了しコミットをすると、self-hostedでbuild.ymlが実行されます。
なお、こちらに記載がありますが、ワークフローファイルは、リポジトリの.github/workflowsディレクトリに保存する必要があるのでご注意ください。

実行結果はActionタブから確認できます。
おそらく以下の画像のような結果になっていると思います。
これでローカルにあるself-hostedに追加されたマシンから実行できるようになりました。
ひとまずこれで基本設定は完了になります。

Unityのビルドスクリプトを作成する

ここからは本格的にビルド処理を実装していきます。

まずはUnityでビルドスクリプトを書きます。

using System;
using System.Linq;
using UnityEngine;
using UnityEditor;
using UnityEditor.Build.Reporting;
using System.Collections.Generic;
using UnityEditor.iOS.Xcode;
using UnityEditor.Callbacks;

public class MobileBuild
{
    static string[] GetEnabledScenes()
    {
        return (
                   from scene in EditorBuildSettings.scenes
                   where scene.enabled
                   where !string.IsNullOrEmpty(scene.path)
                   select scene.path
               ).ToArray();
    }

    private static void BuildAndroid()
    {
        // Setting for Android
        EditorPrefs.SetBool("NdkUseEmbedded", true);
        EditorPrefs.SetBool("SdkUseEmbedded", true);
        EditorPrefs.SetBool("JdkUseEmbedded", true);
        EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Gradle;
        PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);

        // Build
        bool result = Build(BuildTarget.Android);

        // Exit Editor
        EditorApplication.Exit(result ? 0 : 1);
    }

    private static void BuildIOS()
    {
        // Setting for iOS
        PlayerSettings.SetScriptingBackend(BuildTargetGroup.iOS, ScriptingImplementation.IL2CPP);
        EditorUserBuildSettings.iOSBuildConfigType = iOSBuildType.Debug;

        // Build
        bool result = Build(BuildTarget.iOS);

        // Exit Editor
        EditorApplication.Exit(result ? 0 : 1);
    }

    private static bool Build(BuildTarget buildTarget)
    {
        // Get Env
        string   outputPath   = GetEnvVar("OUTPUT_PATH");               // Output path
        string   bundleId     = GetEnvVar("BUNDLE_ID");                 // Bundle Identifier
        string   productName  = GetEnvVar("PRODUCT_NAME");              // Product Name
        string   companyName  = GetEnvVar("COMPANY_NAME");              // Company Name

        outputPath = AddExpand(buildTarget, outputPath);

        Debug.Log("[MobileBuild] Build OUTPUT_PATH :" + outputPath);
        Debug.Log("[MobileBuild] Build BUILD_SCENES :" + String.Join("", GetEnabledScenes()));

        // Player Settings
        BuildOptions buildOptions;
        buildOptions = BuildOptions.Development | BuildOptions.CompressWithLz4;

        if (!string.IsNullOrEmpty(companyName)) { PlayerSettings.companyName = companyName; }

        if (!string.IsNullOrEmpty(productName)) { PlayerSettings.productName = productName; }

        if (!string.IsNullOrEmpty(bundleId)) { PlayerSettings.applicationIdentifier = bundleId; }

        // Build
        var report = BuildPipeline.BuildPlayer(GetEnabledScenes(), outputPath, buildTarget, buildOptions);
        var summary = report.summary;

        // Build Report
        for (int i = 0; i < report.steps.Length; ++i)
        {
            var step = report.steps[i];
            Debug.Log($"{step.name} Depth:{step.depth} Duration:{step.duration}");

            for (int d = 0; d < step.messages.Length; ++d)
            {
                Debug.Log($"{step.messages[d].content}");
            }
        }

        if (summary.result == BuildResult.Succeeded)
        {
            Debug.Log("<color=white>[MobileBuild] Build Success : " + outputPath + "</color>");
            return true;
        }
        else
        {
            Debug.Assert(false, "[MobileBuild] Build Error : " + report.name);
            return false;
        }
    }

    private static string GetEnvVar(string pKey)
    {
        return Environment.GetEnvironmentVariable(pKey);
    }

    private static string AddExpand(BuildTarget buildTarget, string outputPath)
    {
        switch (buildTarget)
        {
            case BuildTarget.Android :
                outputPath += ".apk";
                break;
        }

        return outputPath;
    }
}

大まかに書くとこのような感じになるかと思います。
ビルド後に実行する処理等は書いていませんので、必要に応じて追加してください。

ローカルで上記のスクリプトが動作するか以下のコマンドをCLIで確認してください。

# 適宜書き換えてください
export COMPANY_NAME=""
export PRODUCT_NAME=""
export BUNDLE_ID=""
export OUTPUT_PATH =""

/Applications/Unity/Hub/Editor/2019.3.0f1/Unity.app/Contents/MacOS/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath ./ -executeMethod MobileBuild.BuildIOS -buildTarget iOS

/Applications/Unity/Hub/Editor/2019.3.0f1/Unity.app/Contents/MacOS/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath ./ -executeMethod MobileBuild.BuildAndroid -buildTarget Android

CLIが実行できたのであればいよいよGitHub Actionsを使った話へ進みます

GitHub Actions で Unity のビルドを行う

Android Build

まずはAndroidのビルドを行います。
Unity2019からAndroidのNDKやJDKがインストール時に追加できるようになりました！
なのでNDKやJDKの設定は各自でお願いします（いい時代になりましたね）

早速build.ymlファイルを書き換えましょう

name: ApplicationBuild

on: [push, pull_request]

env:
  OUTPUT_PATH: ""
  BUNDLE_ID: ""
  PRODUCT_NAME: ""
  COMPANY_NAME: ""
  UNITY_VERSION: 2019.3.0f1
jobs:
  build:
    runs-on: self-hosted
    steps:
    - uses: actions/checkout@v2
    - name: Android Build
      run: |
        /Applications/Unity/Hub/Editor/$UNITY_VERSION/Unity.app/Contents/MacOS/Unity -quit -batchmode -nographics -silent-crashes -logFile \
          -projectPath ./ -executeMethod MobileBuild.BuildAndroid -buildTarget Android

Androidビルドをするだけのシンプルな処理です。
環境変数は各自で適切に入力してください。

いくつかを説明を軽くしますと、

name

name:はワークフローの名前になります。
この名前がリポジトリのアクションページにワークフローに表示されます。

on

on:はワークフローをトリガーするGitHubイベントの名前です。
イベントの種類は多くありこちらにドキュメントとしてまとめてあります。
今回はpushとpull_requestをトリガーにしています。

env

1. envはワークフローの全てのジョブから利用できる環境変数を定義します。
2. jobs.<job_id>.envは<job_id>ジョブから利用できる環境変数を定義します。
3. jobs.<job_id>.steps.envはステップから利用できる環境変数を定義します。

先ほどのbuild.ymlは 2. のenvを使っています。
この後のiOSビルドでも使いますからね。

jobs.job_id.steps.uses

ジョブでステップの一部として実行されるアクションを選択します。
actions/checkoutはワークフローで使用できる標準アクションで、v2を指定することでチェックアウトアクションのv2を利用するという設定になります。(標準のアクションはこちらにまとまっています)

jobs.job_id.steps.run

オペレーティングシステムのシェルを使用してコマンドラインプログラムを実行します。
さらにshellキーワードを使用すると、環境のOSのデフォルトシェルを上書きできます。

iOS Build

続いてiOSビルドです。
今回は時間がなくなったのと複雑になるので、ipaファイルをビルドするところまでは行わず、xcodeprojをビルドするところまで行います。
では、build.ymlを書き換えましょう。

name: ApplicationBuild

on: [push, pull_request]

env:
  OUTPUT_PATH: ""
  BUNDLE_ID: ""
  PRODUCT_NAME: ""
  COMPANY_NAME: ""
  UNITY_VERSION: "2019.3.0f1"
jobs:
  android-build:
    runs-on: self-hosted
    steps:
    - uses: actions/checkout@v2
      with:
        path: android
    - name: Android Build
      run: |
        /Applications/Unity/Hub/Editor/$UNITY_VERSION/Unity.app/Contents/MacOS/Unity -quit -batchmode -nographics -silent-crashes -logFile \
          -projectPath ./android -executeMethod MobileBuild.BuildAndroid -buildTarget Android
  ios-build:
    runs-on: self-hosted
    steps:
    - uses: actions/checkout@v2
      with:
        path: ios
    - name: iOS Build
      run: |
        /Applications/Unity/Hub/Editor/$UNITY_VERSION/Unity.app/Contents/MacOS/Unity -quit -batchmode -nographics -silent-crashes -logFile \
          -projectPath ./ios -executeMethod MobileBuild.BuildIOS -buildTarget iOS

書き方が変わった箇所がありますね。
actions/checkoutにwith:キーワードを使ってpath:の設定を渡しています。
こうしている理由は、AndroidとiOSで利用するフォルダを分けてインポート時間やビルド時間の高速化するためです。

この状態でpushしてみましょう。
self-hostedに登録したサーバーが動作してビルドが実行されるはずです。
AndroidとiOSのビルドが成功すると以下のような画面になります。

暗号化されたシークレットを利用する

実際に運用しようとなると、ymlに書きたくない情報を渡したいケースがあると思います。
その場合は GitHub のリポジトリの Setting -> Secret ページへいき Add a new secret をクリック。
シークレットとは、暗号化された環境変数のことです。
NameとValueをそれぞれ入力します。

ここで設定した値をワークフローで利用するには

env:
  SOME_PARAM: ${{ secrets.SOME_PARAM }}

のように記述することで可能です。
これでpasswordやTOKENの情報を渡すことができますね！
なお、シークレットの制限として
1. ワークフローで最大100のシークレットを持てる
2. シークレットの容量は最大64KB
の2点があります。
参考： 暗号化されたシークレットの作成と利用

終わりに

個人的にとてもいいツールだと感じました。
具体的には以下の点に可能性があると思います
1. マシンスペックをこちらで自由にカスタマイズできる（self-hostedの場合）
2. CI/CDがGitHubで完結する
3. Jenkinsから解放される（アセットバンドルをどうするのかという問題はありますが・・・）

他にもCircleCI(MacOS)と違ってUnityのインストールを毎回行う必要がなかったりと比較すると優れている点が多いなという印象です。
簡単な導入まででしたが、以上になります。
参考になれば幸いです。

はじめに

以前、UniRx オペレータ逆引きという記事は書いたのですが、正引きがなかったので改めてまとめました。

フィルタ系

名前	効果・用途	備考
Where<T>	1:OnNextメッセージの内容を条件式でフィルタリングする	後ろがSelectの場合は最適化が自動的に走る
	2:OnNextメッセージの内容および発行回数でフィルタリングする
OfType<T>	指定した型にキャスト可能なメッセージのみ通す	Castとの違いは、変換失敗時に”何もしない”こと
IgnoreElements<T>	すべてのOnNextメッセージをフィルタリングする	何も通さない
Distinct<T>	過去に入力された同値のメッセージをフィルタリングする	Func<TSource, TKey>で比較値の取り出し方法の指定、およびIEqualityComparerの指定が可能
DistinctUntilChanged<T>	直前に入力されたメッセージと同値の場合にフィルタリングする	Func<TSource, TKey>で比較値の取り出し方法の指定、およびIEqualityComparerの指定が可能
First<T>	条件を満たした最初の1つのOnNextメッセージのみを取り出したあと、OnCompletedメッセージをセットで発行する	条件式を指定可能。OnNextメッセージが1つも入力されなかった場合はOnError(InvalidOperationException)が発行される。
FirstOrDefault<T>	条件を満たした最初の1つのOnNextメッセージのみを取り出したあと、OnCompletedメッセージをセットで発行する	条件式を指定可能。OnNextメッセージが1つも入力されなかった場合はOnNext(default<T>)が発行される。
Last<T>	条件を満たした最後の1つのOnNextメッセージのみを取り出したあと、OnCompletedメッセージをセットで発行する	条件式を指定可能。OnNextメッセージが1つも入力されなかった場合はOnError(InvalidOperationException)が発行される。
LastOrDefault<T>	条件を満たした最後の1つのOnNextメッセージのみを取り出したあと、OnCompletedメッセージをセットで発行する	条件式を指定可能。OnNextメッセージが1つも入力されなかった場合はOnNext(default<T>)が発行される。
Single<T>	条件を満たすOnNextメッセージは必ず1回入力されるという制約をつける	入力が0回だった、または2回以上条件を満たすOnNextメッセージが入力された場合はOnError(InvalidOperationException)が発行される。
SingleOrDefault<T>	条件を満たすOnNextメッセージは必ず1回入力されるという制約をつける	入力が0回だった、または2回以上条件を満たすOnNextメッセージが入力された場合はOnNext(default<T>)が発行される。
Skip<T>	1:先頭から指定した個数のOnNextメッセージを無視する	引数はint(無視する個数）
	2:購読開始から指定した期間メッセージを無視する	引数はTimeSpanおよび使用するScheduler
SkipWhile<T>	条件を満たす間はメッセージを無視する。一度でも条件を満たさなくなるとそれ以降は常に通過させる。
Take<T>	1:先頭から指定した個数のOnNextメッセージのみ通過させ、その直後にOnCompletedメッセージを発行する	引数はint(通過させる個数）
	2:購読開始から指定した期間のみメッセージを通過させる。その後はOnCompletedメッセージを発行する	引数はTimeSpanおよび使用するScheduler
TakeWhile<T>	条件を満たす間のみメッセージを通過させる。条件を満たさなくなるとOnCompletedメッセージを発行する
TakeUntil<T>	他のObservableからのOnNextメッセージ入力を受けた瞬間に、OnCompletedメッセージを発行する	Observableを外から止めたいときに使える
TakeUntilDestroy<T>	指定したGameObjectおよびComponentが破棄されたタイミングでOnCompletedメッセージを発行する	GameObjectなどに連動してObservableを止めたいときに使える
TakeUntilDisable<T>	指定したGameObjectおよびComponentがOnDisable()されたタイミングでOnCompletedメッセージを発行する
TakeLast<T>	1:OnCompletedメッセージが入力されたタイミングで、直前のOnNextメッセージを指定の個数分取り出す	OnCompletedメッセージが入力されるまで動作しない
	2:OnCompletedメッセージが入力されたタイミング、直前のOnNextメッセージを指定の期間分取り出す	OnCompletedメッセージが入力されるまで動作しない
Throttle<T>	短期間に大量にメッセージが入力された場合はそれを無視し、落ち着いたタイミングで最後の1つだけを取り出して流す	引数はTimespan（落ち着いたと判断するまでの猶予時間）
ThrottleFrame<T>	短期間に大量にメッセージが入力された場合はそれを無視し、落ち着いたタイミングで最後の1つだけを取り出して流す	引数はフレーム数
ThrottleFirst<T>	1度OnNextメッセージが入力されたらそれを流し、そのあとは一定時間メッセージを無視する	連打の防止などに使える。引数はTimespan
ThrottleFirstFrame<T>	1度OnNextメッセージが入力されたらそれを流し、そのあとは一定時間メッセージを無視する	連打の防止などに使える。引数はフレーム数

メッセージの変換系

名前	効果・用途	備考
Select<T>	1:OnNextメッセージの内容を別の値に変換する	後ろがWhereの場合は最適化が自動的に走る
	2:OnNextメッセージおよび発行回数を用いて別の値に変換する
Cast<T>	OnNextメッセージを指定した型にキャストする	キャスト失敗時にはOnErrorメッセージが発行される
AsUnitObservable	OnNextメッセージの型をUnit型に変換する	Select(_ => Unit.Default)の省略記法
AsSingleUnitObservable	Observableが終了するタイミングでUnit型のOnNextメッセージを1回だけ発行する	LastOrDefault().AsUnitObservable()

メッセージやストリームの合成系

名前	効果・用途	備考
Merge<T>	1.複数のストリームの内容を並列に結合する	引数はIObservable<T>[]
	2.IObservable<IObservable<T>>をIObservable<T>にまとめる	IObservable<IObservable<T>>に対する拡張メソッド
	3.複数のストリームの内容を並列に結合する	IEnumerable<IObservable<T>>に対する拡張メソッド
Concat<T>	1.複数のストリームの内容を直列に結合する	引数はIObservable<T>[]
	2.IObservable<IObservable<T>>を先頭から順番に購読する	IObservable<IObservable<T>>に対する拡張メソッド
	3.複数のIObservable<T>を先頭から順番に購読する	IEnumerable<IObservable<TSource>>に対する拡張メソッド
SelectMany<T>	1.OnNextメッセージを使って新しいObservableを生成し、それを並列に合成する	flatMapに相当する
	2.OnNextメッセージを使って新しいObservableを生成し、そのメッセージを入力値と合成してから、並列に合成する	引数は「Func<T, IObservable<TR>> collectionSelector」「Func<T, TC, TR> resultSelector」の2つ
ContinueWith<T>	SelectMany<T>の軽量版。1回しか実行されない代わりに軽量。	1回しかメッセージが発行されない非同期処理に向く
Switch<T>	購読する対象のObservableを次々に切り替える	IObservable<IObservable<T>>に対してのみ使える
Aggregate<T>	OnNextメッセージに対して加工を行い、その結果を記録してさらに次のメッセージに引き継ぐ	Scan<T>との違いは、OnCompletedメッセージが発行されたタイミングで最終結果を出力する
Scan<T>	OnNextメッセージに対して加工を行い、その結果を記録してさらに次のメッセージに引き継ぐ	Aggregate<T>との違いは、こちらは1回処理するたびにメッセージを発行する
Buffer<T>	1.複数のOnNextメッセージを指定した個数分まとめて、1つのOnNextメッセージに加工する	count == skip
	2.複数のOnNextメッセージを指定した個数分まとめて、1つのOnNextメッセージに加工したあと、指定個数スキップする	countとskipを別々に設定できる。Buffer(count:2, skip:1)にすると直前のメッセージとセットにしてメッセージを発行できる。
	3.指定の時間間隔でメッセージをまとめる
	4.指定の時間間隔でメッセージをまとめたあと、指定した時間計測を一時中断する
	5.個数指定と時間指定を両方組み合わせてメッセージをまとめる	時間か個数どちらかの条件を満たしたタイミングで出力される
	6.メッセージをまとめ、外部からメッセージ入力されたタイミングで出力する	引数はIObservable<TWindowBoundary>。TWindowBoundaryの型はなんでもよい
BatchFrame<T>	1.指定したフレーム数の間に発行されたOnNextメッセージを1つにまとめる	フレーム数と、FrameCountTypeを指定できる
	2.メッセージのタイミングを指定のFrameCountTypeのタイミング変換する	IObservable<Unit>の場合
PairWise<T>	1. 1個前のメッセージと最新のメッセージをセットにして出力する	Buffer(count:2, skip:1)とだいたいおなじ挙動
	2. 1個前のメッセージと最新のメッセージをセットにして、それをさらに加工して出力する	Buffer(count:2, skip:1).Select()に似ている
Zip<TLeft,TRight,TResult>	1. 型が異なる2つのストリームを購読し、値がそれぞれセットで揃ったタイミングで加工して出力する	IObservable<TLeft>に対してIObservable<TRight>を合成し、IObservable<TResult>になる
Zip<T>	2. 型が同じストリームを購読し、値がそれぞれセットで揃ったタイミングで加工して出力する。最大7ストリームまで合成できる	IObservable<T>に対する拡張メソッド
Zip<T>	3. 型が同じ複数のObservableをまとめ、IList<T>として出力する	「IEnumerable<IObservable<T>>に定義された拡張メソッド」または「Observable.Zip」から利用できる。合成できるストリーム数に上限はない
ZipLatest<TLeft,TRight,TResult>	1. 型が異なる2つのストリームを購読し、値がそれぞれセットで揃ったタイミングで最新値のみを取り出して加工して出力する	Zipとの違いは、こちらは余剰に入力されたメッセージは破棄される
ZipLatest<T>	2. 型が同じストリームを購読し、値がそれぞれセットで揃ったタイミングで最新値のみを取り出して加工して出力する。最大7ストリームまで合成できる	Zipとの違いは、こちらは余剰に入力されたメッセージは破棄される
CombineLatest<TLeft,TRight,TResult>	過去に入力されたメッセージ値を記憶し、それを流用して合成を強制的に行う	Zipとの違いは、値がセットにならなくてもメッセージを無理やり合成する
WithLatestFrom<TLeft,TRight,TResult>	1つのストリームを主軸とし、そこに別のストリームの最新値を合成する	別のストリームのメッセージを、もう片方のストリームのタイミングで読み取る、といったことができる。例:Update()で発行されたメッセージをFixedUpdate()で読み取る
Observable.WhenAll<T>	複数のObservableがすべて終了状態になるのを待ち、完了時にその結果をまとめて通知する	staticメソッド
Amb<T>	複数のストリームのうち、もっとも早くメッセージが到達したストリームをひとつだけ採択する

ストリームそのものを加工する

名前	効果・用途	備考
Delay<T>	指定した時間分、OnNextとOnCompletedメッセージを遅延させる	OnErrorは素通しする
DelayFrame<T>	指定したフレーム分、OnNextとOnCompletedメッセージを遅延させる	OnErrorは素通しする
DefaultIfEmpty<T>	1回もOnNextメッセージが入力されずにOnCompletedメッセージが入力された場合に、デフォルト値を発行する
StartWith<T>	1. 購読された瞬間に指定の値のOnNextメッセージを一番最初に発行する
StartWith<T>	2. 購読された瞬間に指定の関数を実行しその結果をOnNextメッセージとして一番最初に発行する	登録した関数は購読された瞬間に実行される
StartWith<T>	3. 購読された瞬間に指定された複数の値を一番最初に発行する	指定された値はそれぞれ個別のOnNextメッセージとして発行される
GroupBy<TSource, TKey>	1. OnNextメッセージを指定した条件でグループ分けを行い、それぞれに分割したストリームとして出力する	戻り値がIObservable<IGroupedObservable<TKey, TSource>>型になる
GroupBy<TSource, TKey, TElement>	2. OnNextメッセージを指定した条件でグループ分けを行い、それぞれに分割したストリームにした上でそれを変換してから出力する	戻り値がIObservable<IGroupedObservable<TKey, TElement>>型になる
Repeat<T>	OnCompletedメッセージが入力されると、自分より上流のストリームに対して再購読を実行する	ストリームが完了したときにSubscribe()を再実行してくれる。無限ループに注意
RepeatSafe<T>	Repeat<T>とほぼ同じ。ただし、OnCompletedメッセージが連続して入力されると処理を中断する	Repeat<T>を安全にしたもの
RepeatUntilDestroy<T>	指定したGameObjectかComponentが破棄されるまでの間、Repeat<T>として機能する	Repeat<T>を安全にしたもの
RepeatUntilDisable<T>	指定したGameObjectかComponentがDisableされるまでの間、Repeat<T>として機能する	Repeat<T>を安全にしたもの
Sample<T>	1. OnNextメッセージを指定の時間間隔でサンプリングする	一定時間ごとに、そのときの最新値を出力する
Sample<T>	2. OnNextメッセージを別のストリームの入力タイミングでサンプリングする	別ストリームから入力があるたびに、そのときの最新値を出力する
SampleFrame<T>	OnNextメッセージを指定のフレーム間隔でサンプリングする
Timeout<T>	1. OnNextメッセージの発行間隔が一定時間あいたらOnErrorメッセージを発行する
Timeout<T>	2. 指定の時刻までにストリームが完了しなかったらOnErrorメッセージを発行する
TimeoutFrame<T>	OnNextメッセージの発行間隔が一定フレーム数あいたらOnErrorメッセージを発行する
Timestamp<T>	OnNextメッセージにそのメッセージが発行された時刻を付与する	戻り値はIObservable<Timestamped<T>>
TimeInterval<T>	OnNextメッセージが発行された時間間隔を計測し、それをメッセージに付与する	戻り値はIObservable<TimeInterval<T>>
FrameTimeInterval<T>	OnNextメッセージが発行された時間間隔を計測し、それをメッセージに付与する。ただし時間の計測にUnityのTime.timeまたはTime.unscaledTimeを用いる	時間の計測方法が違う以外はTimeInterval<T>と同じ
FrameInterval<T>	直前のOnNextメッセージとの経過フレーム数をOnNextメッセージに付け加える
Synchronize<T>	メッセージ処理に排他ロックを行う	lockに用いるオブジェクトを複数ストリームで共有することもできる

エラーハンドリング

名前	効果・用途	備考
Catch<T, TException>	指定した型の例外を含むOnErrorメッセージがきた場合に登録した処理を実行し、任意のストリームに差し替える。型が一致しないOnErrorメッセージは無視する	引数の型はFunc<TException, IObservable<T>> errorHandler。TExceptionの型は必ず明示しないといけない
Observable.Catch<T>	指定された複数のストリームを先頭から順番に購読し、OnNextメッセージをそのまま伝える。途中でOnErrorメッセージが発生すると次のストリームにスイッチする。OnCompletedメッセージが発行されたタイミングで終了する	失敗したら次へ、失敗したら次へ、成功するまで繰り返す
CatchIgnore<T, TException>	指定した型の例外を含むOnErrorメッセージがきた場合に登録した処理を実行し、Observable.Empty<T>に差し替える。型が一致しないOnErrorメッセージは無視する	エラーが起きたときにもみ消して終了する
Retry<T>	OnErrorメッセージが発行されたときに、上流のストリームを再購読する	計何回まで試行するか指定できる
OnErrorRetry<T>	1. OnErrorメッセージが発行されたときに、上流のストリームを再購読する	引数を何も指定しない場合。Retry<T>と同じ挙動をする
OnErrorRetry<T, TException>	2. 指定した型の例外を含むOnErrorメッセージがきた場合に登録した処理を実行し、上流のストリームを再購読する	Catch + Retryの複合
OnErrorRetry<T, TException>	3. 指定した型の例外を含むOnErrorメッセージがきた場合に登録した処理を実行し、一定時間待ってから上流のストリームを再購読する	Catch + Retryの複合だが、リトライするまでのディレイをつけられる
Finally<T>	ストリームが解体されるタイミングで登録した関数を実行する	ストリームの解体とは次に挙げるシチュエーションのこと。「OnCompletedメッセージが発行される」「OnErrorメッセージが発行される」「Disposeにより購読が中断される」「Subscribeで登録した関数の処理途中で例外が発生する」

Hot変換用

名前	効果・用途	備考
Multicast<T>	指定のISubjectを用いてHot変換する
Publish<T>	1. Subject<T>を用いてHot変換する	Multicast(new Subject<T>())に相当
Publish<T>	2. BehaviorSubject<T>を用いてHot変換する	初期値を設定した場合はこちらの挙動になる。Multicast(new BehaviorSubject<T>())に相当
PublishLast<T>	AsyncSubject<T>を用いてHot変換する	Multicast(new AsyncSubject<T>())に相当。OnErrorメッセージもキャッシュしてしまうのでエラーハンドリングに注意
Replay<T>	ReplaySubject<T>を用いてHot変換する	Multicast(new ReplaySubject<T>())に相当
RefCount<T>	Hot変換時、自分を購読するObserverがいる場合にストリームを稼働させる。Observerがいなくなると自動で停止する	IConnectableObservable<T>に対してのみ利用可能
Share<T>	Publish<T>().RefCount()の省略記法

Schedulerの切り替え

名前	効果・用途	備考
ObserveOn<T>	メッセージの実行コンテキストを指定のSchedulerに切り替える
ObserveOnMainThread<T>	メッセージの実行コンテキストをUnityメインスレッドに切り替える	MainThreadDispatchTypeでメインスレッド上のどのタイミングにするかを指定できる
SubscribeOn<T>	ストリームの初期構築を指定のSchedulerで行う	あまり使うことはない
SubscribeOnMainThread<T>	ストリームの初期構築をUnityメインスレッド上で行う
DelaySubscription<T>	1. 指定された時間だけ待ってからSubscribe()を実行する	購読開始のタイミングをずらせる
DelaySubscription<T>	2. 指定された時刻になったらSubscribe()を実行する	購読開始のタイミングを指定できる
DelayFrameSubscription<T>	指定されたフレーム数だけ待ってからSubscribe()を実行する	UpdateやFixedUpdateのカウント数を指定できる

その他

名前	効果・用途	備考
Do<T>	ストリームのメッセージを用いて副作用を起こす。メッセージそのものは加工しない	ストリームの途中で、ストリーム外部の状態を変化させるときに使う
DoOnError<T>	OnErrorメッセージを用いて副作用を起こす。メッセージそのものは加工しない	OnErrorメッセージのみに反応
DoOnCompleted<T>	OnCompletedメッセージを用いて副作用を起こす。メッセージそのものは加工しない	OnCompletedメッセージのみに反応
DoOnTerminate<T>	OnErrorまたはOnCompletedメッセージが発行されたとき副作用を起こす。メッセージそのものは加工しない	OnErrorメッセージまたはOnCompletedメッセージに反応
DoOnSubscribe<T>	ストリームがSubscribe()されたときに副作用を起こす	購読された瞬間をログに出したりするとデバッグに便利
DoOnCancel<T>	ストリームがDispose()によってキャンセルされたときに副作用を起こす	OnErrorメッセージやOnCompletedメッセージには反応しない
ForEachAsync<T>	非同期処理の結果を伝搬しつつ、そのメッセージ消費を行う	Do().Last().AsUnitObservable()に挙動は似ている。AsyncReactiveCommandと組み合わせると非常に便利
Materialize<T>	すべてのメッセージをOnNext(Notification<T>)メッセージへと変換する	OnErrorメッセージやOnCompletedメッセージをOnNextメッセージに格納してしまう。どんなメッセージが発行されたのかを列挙できるので、テストするときに便利
Dematerialize<T>	Materialize<T>によって変換されたメッセージをもとに戻す
AsObservable<T>	指定のオブジェクトのインタフェースをIObservable<T>に制限する	オブジェクトのダウンキャストやクロスキャストを防止できる
ToArray<T>	発行されたOnNextメッセージをすべてキャッシュし、OnCompletedメッセージが入力されたタイミングで1つのOnNext(T[])メッセージに変換して出力する
ToList<T>	発行されたOnNextメッセージをすべてキャッシュし、OnCompletedメッセージが入力されたタイミングで1つのOnNext(IList<T>)メッセージに変換して出力する
Wait<T>	ストリームが完了するのをスレッドをブロックして待機する	メインスレッドで使うとフリーズするので常用禁止

◆写在开头

这次是第②回、
手的表示，与可抓住物体的制作。

第①回的内容请点这里
第①回：导入APP、进行运行状态确认

（还有日文版哦）
PS：因为我的制作环境是日语环境，所以下面的软件截图，都是日文版的截图。
表示内容不同，但菜单的位置，作用等都是一样的，
根据说明和参考截图应该能找到相对应的功能的所在位置。

◆ 开发环境

macOS Mojave 版本 10.14.6
Unity 2018.4.12f1
Android SDK

◆ 制作顺序

• 1. 在画面中表示手
  • 1_1. 导入LocalAvatarWithGrab
  • 1_2. Ovr Avatar 的设定
  • 1_3. 发行与设置OculusAPP用ID
• 2. 追加一个可以被抓住的物体
• 3. 运行确认

1.在画面中表示手

1_1. 导入LocalAvatarWithGrab

新建一个Scene
具体的制作方法请参考上回的内容第①回：导入APP、进行运行状态确认

想要抓住物体，首先要有抓住物体用的手。
这次依旧使用上一回导入的Oculus Integration中的功能，
在里面找到LocalAvatarwithGrab，它是搭载了抓住物体功能的Prefab

「LocalAvatarWithGrab」在
「Assets」→「Oculus」→「SampleFramework」→「Core」→「AvatarGrab」→「Prefabs」里面可以找到。
文件夹的层次比较深、推荐使用Project上方的搜索栏，直接搜索「LocalAvatarWithGrab」。

找到后，将它拖入Hierarchy后自动追加完毕。
确认追加完成后、点开「Inspector」→「Transform」完成一些初始设定。
这里的设定基本是自由的，这次只把「Scale」调整成1.7便可。

设置调整完成后、将上一回制作的「OVRCameraRig」删除掉。
因为「LocalAvatarWithGrab」里面已经存在「OVRCameraRig」了，所以之前的就不需要了。

1_2. Ovr Avatar 的设定

接着，点击刚才追加的「LocalAvatarWithGrab」。
点击「Inspector」→「Ovr Avatar」→「Shaders 」调整设定。

点击「Controller Shader」右边的小圆圈，
会自动弹出「Shader」的设置画面。

直接在搜索栏搜索「AvatarPBRV2Simple」
找到文件名对得上的「Shader」后点击，自动设置完成。

设置完成后、「Shader」会变成如图所示的状态。

1_3. 发行与设置OculusAPP用ID

为了能够表示追加完成的手、需要OculusAPP用ID「Create android manifest」。

AppID需要访问Oculus主页，申请后获得。
这里就不一一详细说明了。

ID发行后、回到Unity。
选择菜单的「Oculus] →「Avatars」→「Edit Setting」
弹出「OvrAvatarSettings」窗口。

将刚才发行的ID设置好。

最后，为了手能够正确显示，需要设置「Create android manifest」。
它的设置方法非常简单。
点击「Oculus」→「Tools」→「Create store-compatible AndroidManifest.xml」即可完成。

2. 追加一个可以被抓住的物体

在「Hierarchy」中右键，选择「3D」→「Object」→「Cube」后，画面中会自动追加一个方块。
方块尺寸可自由调整。

选择刚刚追加的「Cube」
在「Inspector」中选择「Add Component」找到「Rigidbody」和「OVR Grabbable 」追加。
「Box Collider」在生成方块的时候应该自动生成了、但如果没有的话，需要用上面同样的方式追加进去。
这样方块的设置就完成了。

3. 运行确认

导入APP之前、推荐先在Unity上运行一次、确认一下方块是否会自然落下。

如果没有问题，那么就把APP导入Oculus，实际确认以下是否运行正常吧。

◆はじめに

第②回ですね、
手の表示と物を掴む方法をやります。

第①回は↓に参照してください。
第①回：APPをビルドして、動作確認する

（日本語と中国版あります）

◆ 開発環境

macOS Mojave バージョン 10.14.6
Unity 2018.4.12f1
Android SDK

◆ 手順

• 1. 手を表示する
  • 1_1. LocalAvatarWithGrab導入
  • 1_2. Ovr Avatar の設定
  • 1_3. OculusのアプリのID発行と設置
• 2. 掴む物体の追加と設定
• 3. 動作確認

1.手を表示する

1_1. LocalAvatarWithGrab導入

新規シーンを作ります。
具体的な制作方法は前回の第①回：APPをビルドして、動作確認するを参照してください。

物を掴む為には、まず手を表示する必要が有ります。
前回導入した、Oculus Integrationの中には、物を掴む機能を搭載しているLocalAvatarwithGrab というプレハブが存在しています。
今回は、それを使います。

「Assets」→「Oculus」→「SampleFramework」→「Core」→「AvatarGrab」→「Prefabs」
の中に「LocalAvatarWithGrab」あります。
階層は深い為、Projectの検索欄で「LocalAvatarWithGrab」と検索を掛けたら探しやすいです。

これをHierarchyにドラックし、追加します。
追加したら、「Inspector」→「Transform」でポジションなどを設定します。
今回は、 「Scale」は1.7、他は全部0にします。

設置完了後、前回作った「OVRCameraRig」を削除します。
「LocalAvatarWithGrab」の中にも「OVRCameraRig」が存在している為、不要です。

1_2. Ovr Avatar の設定

続いて、追加した「LocalAvatarWithGrab」クリックし、
「Inspector」→「Ovr Avatar」→「Shaders 」の設定を調整します。

「Controller Shader」右側の丸をクリック。
「Shader」を設定する画面に遷移するはずです。

検索欄で「AvatarPBRV2Simple」検索し、
ファイル名が合っている「Shader」をダブルクリックし、設定する事ができます。

設定したら、「Shader」はこのような状態になります。

1_3. OculusのアプリのID発行と設置

追加した手を表示するためには、OculusのアプリのIDと「Create android manifest 」が必要です。

アプリのIDは、
Oculus ホームページのダッシュボードにアクセスし、
「新しいアプリを作成」からアプリを登録して、発行出来ます。
Oculus Developer Dashboard
詳しいID発行方法は、ここでは割愛します。

ID発行後、Unityに戻ります。
メニューから「Oculus] →「Avatars」→「Edit Setting」をクリックすると、
「OvrAvatarSettings」が表示されます。

先程発行したアプリIDを設定して、これでID設定は完了になります。

最後、手を正しく表示するために「Create android manifest」を設置する必要があります。
設置方法は非常に簡単、
「Oculus」→「Tools」→「Create store-compatible AndroidManifest.xml」をクリックするだけです。

2. 掴む物体の追加と設定

掴む用のオブジェクトを追加します。
「Hierarchy」で右クリック「3D」→「Object」→「Cube」を追加します。
サイズは自由です。

追加した「Cube」を選択します。
「Inspector」→「Add Component」で「Rigidbody」と「OVR Grabbable 」を検索し、追加します。
「Box Collider」は最初から存在するはずですが、なければ「Rigidbody」と同じ方法で追加します。
これで、設置完了です。

3. 動作確認

ビルドする前に、まずUnity上で一回実行して、「Cube」落下するかどうか確認します。

問題無ければ、ビルドして、実機で動作確認しましょう。

はじめに

UniRxのObservableと、UniTaskはそれぞれ相互変換することができます。
今回はその中でも少し変わった変換パターンを紹介したいと思います。

※ System.Linq UniRx UniRx.Async のusingを忘れずに

IEnumerable<UniTask<T>> -> IObservable<T>

複数のUniTask<T>をまとめて、1つのIObservable<T>にする方法です。
やり方が何パターンかあります。

// 対象
IEnumerable<UniTask<string>> tasks = CreateSample();

// ---

// 並列にまとめる（要素の順序を無視して、終わったものから結果を返す）
IObservable<string> parallel = tasks
    .Select(x => x.ToObservable()) // IE<IO<T>>
    .Merge(); // IO<T>

// 直列にまとめる（要素の先頭から順番に結果を返す)
IObservable<string> sequential = tasks
    .Select(x => x.ToObservable()) // IE<IO<T>>
    .Concat(); // IO<T>


// 全部終わってからまとめて結果をとるなら（IO<IE<T>>）
IObservable<IList<string>> whenAll = tasks
    .Select(x => x.ToObservable()) // IE<IO<T>>
    .Zip(); // IO<IList<T>>

// でも、全部まとめてとるならUniTask.WhenAllでいいのでは?
UniTask<string[]> whenAll2 = UniTask.WhenAll(tasks);

UniTask<IEnumerable<T>> -> IObservable<T>

さっきとネストの仕方が逆のパターン。
UniTask<IE<T>>を分解して1つのIObservable<T>にする方法です。
2パターンあるけど結果は同じです。

// 対象
UniTask<IEnumerable<string>> task = CreateSample();

// パターン1
IObservable<string> p1 = task
    .ToObservable() // IO<IE<T>>
    .Select(x => x.ToObservable()) // IO<IO<T>>
    .Merge(); // IO<T>

// パターン2
IObservable<string> p2 = task
    .ToObservable() // IO<IE<T>>
    .SelectMany(x => x.ToObservable()); // IO<T>

IObservable<T> -> UniTask<IEnumerable<T>>

IObservable<T>が発行するすべてのメッセージを「まとめて」待ち受けるUniTask<T>を作りたい場合。

// 対象
IObservable<string> observable = CreateSample();

// ToArray()してからToUniTask()でOK
UniTask<string[]> task = observable.ToArray().ToUniTask();

IObservable<UniTask<T>> -> IObservable<T>

ObservableがUniTaskを扱う場合に、それを1つのObservableにまとめる。

// 対象
IObservable<UniTask<string>> observable = CreateSample();

// 並列（終わった順に結果を出すなら）
IObservable<string> parallel = observable.SelectMany(x => x.ToObservable());

// 直列（もとのIO<T>から発行された順序を維持するなら）
IObservable<string> sequential = observable.Select(x => x.ToObservable()).Concat();

IObservable<UniTask<T>> -> UniTask<IEnumerable<T>>

ObservableがUniTaskを扱う場合に、それをUniTask側にまとめる。

IObservable<UniTask<string>> observable = CreateSample();

// 結果は先に終わったUniTaskの順番になる
UniTask<string[]> task = observable
    .SelectMany(x => x.ToObservable()) // IO<IO<T>>
    .Merge() // IO<T>
    .ToArray() // IO<T[]>
    .ToUniTask(); // UniTask<T[]>

UniTask<IObservable<T>> -> IObservable<T>

UniTaskの中にObservableが入り込んじゃった場合。

// 対象
UniTask<IObservable<string>> task = CreateSample();

// taskをIO<IO<T>>に変換してからMerge()
IObservable<string> observable = task.ToObservable().Merge();

UniTask<IObservable<T>> -> UniTask<IEnumerable<T>>

UniTaskの中にObservableが入り込んじゃったものを、今度はUniTask側にまとめる場合。

// async/await使っちゃうのが楽
private async UniTask<IEnumerable<string>> Unwrap(UniTask<IObservable<string>> task)
{
    var observable = await task;
    return await observable.ToArray();
}

IObservable<IObservable<T>> -> UniTask<IEnumerable<T>>

こんなシチュエーションあるのかよくわからないけど。

IObservable<IObservable<string>> observable = CreateSample();

UniTask<string[]> task = observable
    .SelectMany(x => x) // IO<T>
    .ToArray() // IO<T[]>
    .ToUniTask(); // UniTask<T[]>

まとめ

UniRxとUniTaskはだいたいどんなパターンでもそれぞれに変換することができます。
両者を組み合わせて使い、必要に応じて変換をかけるとよいでしょう。

通っている専門学校でチームでのunityを使ったゲーム制作があり、自分の至らぬ点も見つかったので一人反省会です
私の担当はゲームシーンが切り替わるときのエフェクト作成が主でした

フェードインとフェードアウトのプログラムはTAMA-LABさんのスクリプトを参考にしました
→Unityでフェードイン／フェードアウトを実現する方法(TAMA-LABさん)

Fade_controler.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

public class Fade_controler : MonoBehaviour
{
    float fadeSpeed = 0.01f;        //透明度が変わるスピードを管理
    float red, green, blue, alfa;   //パネルの色、不透明度を管理

    private bool isFadeOut = false;  //フェードアウト処理の開始、完了を管理するフラグ
    private bool isFadeIn = false;   //フェードイン処理の開始、完了を管理するフラグ

    Image fadeImage;                //透明度を変更するパネルのイメージ

    void Start()
    {
        isFadeIn = true;

        fadeImage = GetComponent<Image>();
        red = fadeImage.color.r;
        green = fadeImage.color.g;
        blue = fadeImage.color.b;
        alfa = fadeImage.color.a;
    }

    void Update()
    {
        if (Input.GetMouseButtonDown(0)&&isFadeIn==false)
        {
            isFadeOut = true;
        }

       if (isFadeIn==true)
       {
          StartFadeIn();
       }

       if (isFadeOut==true)
       {
          StartFadeOut();
       }


    }

    void StartFadeIn()
    {
        Debug.Log("1");
        alfa -= fadeSpeed;                //a)不透明度を徐々に下げる
        SetAlpha();                      //b)変更した不透明度パネルに反映する
        if (alfa <= 0)
        {                    //c)完全に透明になったら処理を抜ける
            isFadeIn = false;
            fadeImage.enabled = false;    //d)パネルの表示をオフにする
        }
    }

    void StartFadeOut()
    {
        Debug.Log("2");
        fadeImage.enabled = true;  // a)パネルの表示をオンにする
        alfa += fadeSpeed;         // b)不透明度を徐々にあげる
        SetAlpha();               // c)変更した透明度をパネルに反映する
        if (alfa >= 1)
        {             // d)完全に不透明になったら処理を抜ける
            isFadeOut = false;
            SceneManager.LoadScene("Traning");
        }
    }



    void SetAlpha()
    {
        fadeImage.color = new Color(red, green, blue, alfa);
    }
}

今回の反省点は、この親切でわかりやすいプログラムを自分で理解して扱うまでに一週間かけてしまったことです
理由を考えてみるとフラグを使い慣れておらず使い方を思い出せなかったことや、何がわからないかを整頓できなかったことから、日ごろからプログラムを学ぼうとする意欲が足りなかったことが原因だと考えつきました
これをもとに、どんなゲームを作るか考えることだけでなく、今まで考えたゲームを片っ端から作ることでもっとプログラムに親しもうと思いました
あとゆにてぃがおもったとりにうごいてくれたときはすごくたのしかったしうれしかったです。

制作理由

学校でグループ制作中に戦闘時に攻撃する際にエフェクトがあったほうが戦闘時に単調にならず、またプレイヤーを楽しませる要素の一つになると考えたので制作しました。

Particle Systemを作成する

製作途中のゲームのものをそのまま使用しているため実際には必要のないものが混じっています

まずはHierarchy内で右クリックをしてEffects > Particle Systemで作成します。

今回は攻撃魔法用の爆発エフェクトを例に作成していきます。

パーティクルのカスタマイズ

作成した段階では白い球のようなものが上の方向に拡散しながら上がっていくだけなので、まずは爆発っぽくなるように中心から外側に広がっていくように設定します。
InspectorからShapeを選択し、ConeからSphereに変更します。

これだけだとまだ爆発っぽくないのでもっと爆発に近いエフェクトになるようにしていきましょう。
まずはEmissionを下のように設定します。

これで一度に出現するParticleの数が増加しました。

続けてLimit Velocity over LifetimeとSize over Lifetimeを次のように設定してください。

これで爆発のようなエフェクトにはなりますが少しParticleが残る時間が長いのでもう少し短くしましょう。
DurationとStart Lifetimeの値を次のように設定してください。

最後にRendererのMaterialからお好みのMaterialを選択すれば完成です。

↑こんな感じになります

今回はStandard AssetsのParticleFireballを使用しましたが、ほかに自分が気に入ったものがあればそちらをお使いください。

最後に

今回が初めての投稿になります。こうしたほうがもっと見やすくなる、こっちのほうがもっと爆発っぽいエフェクトになるなどのアドバイスがありましたら是非教えていただきたいです。よろしくお願いいたします。

目的

前回までの、3Dマークアップ言語を動的に出力するWebシステムを作る。

道具立て

比較的慣れてるので、PythonでFlaskを使ってサクッと作ってみる。

時計を作る

データベースとかアクセスしたりAPI使うのも大がかりなので、PoCとして最低限として、アクセス時刻の表示をする時計を作ってみる。
以下、時分秒に対応する球を表示するプログラム。時刻の経過に合わせて動くわけではない。

app.py

from flask import Flask
import datetime
import math

app = Flask(__name__)

@app.route('/')
def clock():
    dt_now = datetime.datetime.now()

    hour = dt_now.hour % 12
    minute = dt_now.minute
    sec = dt_now.second

    yh = 0.2 * math.cos(hour * 2 * 3.141592 / 12)
    xh = 0.2 * math.sin(hour * 2 * 3.141592 / 12)
    ym = 0.4 * math.cos(minute * 2 * 3.141592 / 60)
    xm = 0.4 * math.sin(minute * 2 * 3.141592 / 60)
    ys = 0.35 * math.cos(sec * 2 * 3.141592 / 60)
    xs = 0.35 * math.sin(sec * 2 * 3.141592 / 60)

    homl = '''<homl><head><title>CLOCK</title></head>
<body><a-scene wx=0.2 wy=0.2 wz=0.2>
<a-sphere r=0.05 x=0 y=0 z=0 color=white />
<a-sphere r=0.05 x={xh} y={yh} z=0 color=red />
<a-sphere r=0.03 x={xm} y={ym} z=0 color=green />
<a-sphere r=0.01 x={xs} y={ys} z=0 color=blue />
</a-scene></body></homl>
'''.format(xh=xh,yh=yh,xm=xm,ym=ym,xs=xs,ys=ys)

    return homl

if __name__ == '__main__':
    app.run()

結果

それっぽくなった。
これで、インターネットの世界とXRの世界が簡単につながるようになった。

目的

HTMLに対応するJavaScriptのように、前回の3Dマークアップ言語にスクリプティングシステムとしてLuaを組み込んでみたい。
そのためのとっかかりとして、UnityにLuaエンジンを組み込み、GameObjectをLuaから操作してみる。

道具立て

組み込むLuaエンジンとして、NLuaを使ってみた。
nugetなどで導入する。

Unityプロジェクトとプログラム

Unityのヒエラルキーはこんな感じ。

プログラムは、まず、以下のコードを関係する全オブジェクト（Root,Child1,Cube）にアタッチしておく。これを介してLuaからGameObjectを操作する。

NLuaTest.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace NLuaTestNS
{
    public class NLuaTest : MonoBehaviour
    {
        public NLuaTest getChild(int i)
        {
            return gameObject.transform.GetChild(i).gameObject.GetComponent<NLuaTest>();
        }

        public void setColor(int r, int g, int b, int a)
        {
            gameObject.GetComponent<Renderer>().material.color = new Color((float)r/255f, (float)g/255f, (float)b/255f, (float)a/255f);
        }

        public void setPosition(float x, float y, float z)
        {
            gameObject.transform.localPosition = new Vector3(x/10f,y/10f,z/10f);
        }

        public void setRotation(float x, float y, float z)
        {
            gameObject.transform.localRotation = Quaternion.Euler(x,y,z);
        }
    }
}

そして、以下のコードをRootにアタッチして実行。

NLuaDo.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using NLuaTestNS;
using NLua;

public class NLuaDo : MonoBehaviour
{
    private Lua state;
    private int color;

    // Start is called before the first frame update
    void Start()
    {
        state = new Lua();
        state["root"] = GetComponent<NLuaTest>();
        state.DoString("root:getChild(0):getChild(0):setColor(0,0,0,255)");
    }

    void Update()
    {
        color += 1;
        color %= 256;
        state.DoString("root:getChild(0):getChild(0):setColor("+color+","+color+","+color+",255)");
        state.DoString("root:getChild(0):getChild(0):setPosition(" + color + "," + color + "," + color + ")");
        state.DoString("root:getChild(0):getChild(0):setRotation(" + color + "," + color + "," + color + ")");
    }
}

色を変えるのと、適当なアニメーションをつけてみた。

結果

素直に動いてくれた。

製作理由

学校のグループ製作中に、敵であるunityちゃんの姿を消したいなと思い、このプログラムを書きました。

unityちゃんのメッシュ情報を取得する

製作中のゲームからそのまま持ってきたので余計な物も入ってます

まずunitychanの中にあるmesh_rootを取得します
画像参照

このmesh_rootをつけたり消したりすると以下のようになります

これらを用いて簡単に付いたり消えたりするものを作りました

sample.cs

GameObject mesh;

private void start
{
    float elapsedTime = 0;
    mesh = GameObject.Find("mesh_root");
}
private void update
{
    elapsedTime+=Time.deltaTime;
    if(elapsedTime > 2f)
        mesh.SetActive(true);
    else
        mesh.SetActive(false);
    if(elapsedTime > 4f)
        elapsedTime = 0f;
}

これでunityちゃんが見えたり消えたりするようにできました。

最後に

もっと簡単にできるよ！等のアドバイス等ありましたら
是非教えていただきたいです！よろしくお願いします！

目的

3Dオブジェクトを記述する3Dマークアップ言語をUnityで実装してみる。

マークアップ言語？

ざっくりHTMLみたいな、A-Frameに近いものを作ってみます。

道具立て

HTMLライクなマークアップ言語のパースに、HTML Agility Packを使います。
NuGetで入れることもできますし、サイトからnupkgをダウンロードして7zipなどで展開して、DLLだけ使うということもできます。
.Net 4.5用だったり、.Net Standard 2.0用だったり、いくつか種類があるので、自分のプロジェクトに合ったものを使います。
UnityのDLLのImportセッティングのところで、適切なプラットフォームに対して、適切なDLLが使われるように設定しましょう。

実際のプログラム

以下のプログラムがパーサーのエントリー部分になります。

HomlParser.cs

using System.Collections;
using System.Collections.Generic;
using System.Runtime;
using UnityEngine;
using HtmlAgilityPack;
using Homl.DOM;
using System.Reflection;

namespace Homl.Parser
{
    public class HomlParser
    {
        public static Dictionary<string, ParseNode> nodeTemplates;

        public HomlParser()
        {
            if(nodeTemplates == null)
            {
                nodeTemplates = new Dictionary<string, ParseNode>();

                nodeTemplates.Add("a-scene", new Body());
                nodeTemplates.Add("a-box", new Cube());
                nodeTemplates.Add("a-cylinder", new Cylinder());
                nodeTemplates.Add("a-sphere", new Sphere());
                nodeTemplates.Add("a-link", new ATag());
                nodeTemplates.Add("a-text", new Text());
                nodeTemplates.Add("homl", new Homl());
            }
        }

        public Document Parse(string homl)
        {
            var htmlDoc = new HtmlAgilityPack.HtmlDocument();
            htmlDoc.LoadHtml(homl);

            GameObject documentGO = new GameObject("Document");
            Document document = documentGO.AddComponent<Document>();
            BoxCollider bc = documentGO.AddComponent<BoxCollider>();

            walkinChild(htmlDoc.DocumentNode.ChildNodes, documentGO);

            bc.size = new Vector3(0.3f, 0.3f, 0.3f);
            return document;
        }

        private void walkinChild(HtmlAgilityPack.HtmlNodeCollection nodes, GameObject parent)
        {
            foreach (HtmlAgilityPack.HtmlNode node in nodes)
            {
                GameObject nodeObject = null;
                Debug.Log(node.Name);

                if (nodeTemplates.ContainsKey(node.Name))
                {
                    nodeObject = nodeTemplates[node.Name].parse(node, parent);
                } else
                {
                    nodeObject = parent;
                }

                if (node.HasChildNodes)
                {
                    walkinChild(node.ChildNodes, nodeObject);
                }

            }
        }
    }
}

再帰的にマークアップの構造をたどり、タグ名の辞書から該当タグをパースするオブジェクトを探しながらUnityのGameObjectを作成していきます。

各タグのパーサーは、例えばCubeに対するパーサーが以下のようになっています。

Cube.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using HtmlAgilityPack;

namespace Homl.Parser
{
    public class Cube : ParseNode
    {
        public override GameObject parse(HtmlNode homlNode, GameObject parent)
        {
            PrimitiveProducer pp = GameObject.Find("PrimitiveProducer").GetComponent<PrimitiveProducer>();
            GameObject cube = GameObject.Instantiate(pp.getCube());
            float x = float.Parse(homlNode.GetAttributeValue("x", "0.0f"));
            float y = float.Parse(homlNode.GetAttributeValue("y", "0.0f"));
            float z = float.Parse(homlNode.GetAttributeValue("z", "0.0f"));
            float s = float.Parse(homlNode.GetAttributeValue("size", "0.1f"));
            string color = homlNode.GetAttributeValue("color", "white");

            cube.transform.parent = parent.transform;
            cube.transform.Translate(new Vector3(x, y, z));
            cube.transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);

            Material mat = cube.GetComponent<Renderer>().material;
            mat.color = ColorManager.Instance.getColor(color);
            mat.SetColor("_BaseColor", ColorManager.Instance.getColor(color));

            Vector3 scale = new Vector3(s, s, s);
            Vector3[] verts = cube.GetComponent<MeshFilter>().mesh.vertices;
            Vector3[] newverts = new Vector3[verts.Length];
            int i = 0;
            foreach (Vector3 v in verts)
            {
                v.Scale(scale);
                newverts[i] = v;
                i++;
            }
            cube.GetComponent<MeshFilter>().mesh.vertices = newverts;
            BoxCollider bc = cube.GetComponent<BoxCollider>();
            bc.size = scale;

            DOM.Cube cb = cube.AddComponent<DOM.Cube>();
            return cube;
        }
    }
}

PrimitiveProducerは、プリミティブの3DオブジェクトPrefabの参照を管理しているオブジェクトです。
Attributeの指定の仕方などは、本家のA-Frameと異なるところなので、コンポーネント志向の構造と合わせて抜本的な見直しは必要ですが、
これに加えて、DOMのクラス群を合わせて動かすことで、3DオブジェクトをマークアップからUnity内に生成して、リンクなどの仕組みを作ることもできるようになりました。

表示結果

もとになったマークアップ

天気予報の雪だるまのつもり

<homl>
<head>
<title>Weather</title>
</head>
<body>
<a-scene wx=0.2 wy=0.001 wz=0.2>
<a-cylinder height=0.02 r=0.02 x=0 y=0.18 z=0 color=red />
<a-sphere r=0.1 x=0 y=0.05 z=0 color=white />
<a-sphere r=0.08 x=0 y=0.14 z=0 color=white />
</a-scene>
</body>
</homl>

機能テスト用

<homl>
<head>
<title>TestHoloML</title>
</head>
<body>
<a-scene wx=0.2 wy=0.2 wz=0.2>
<a-box size=0.1 x=0 y=0 z=0 color=blue>
 <a-cylinder height=0.05 r=0.02 x=0.1 y=0.1 z=0.1 color=red />
 <a-sphere r=0.05 x=-0.1 y=-0.1 z=-0.1 color=green />
 <a-text size=0.1 x=0 y=0 z=0 color=blue>ABCDEF</text>
</a-box>
<a-link href=”test.homl”>
 <a-box size=0.1 x=0.1 y=-0.1 z=0.1 color=white />
</a-link>
</a-scene>
</body>
</homl>

3Dグラフ

<homl>
<head>
<title>3D Graph</title>
</head>
<body>
<a-scene wx=0.5 wy=0.001 wz=0.2>
<a-cylinder height=0.2 r=0.05 x=-0.2 y=0.2 z=0 color=red />
<a-cylinder height=0.12 r=0.05 x=-0.1 y=0.12 z=0 color=red />
<a-cylinder height=0.14 r=0.05 x=0 y=0.14 z=0 color=red />
<a-cylinder height=0.08 r=0.05 x=0.1 y=0.08 z=0 color=red />
<a-cylinder height=0.05 r=0.05 x=0.2 y=0.05 z=0 color=red />
</a-scene>
</body>
</homl>

現状ではプリミティブオブジェクトの組み合わせだけなのですが、このように表示が可能になりました。

はじめに

• ZEALS Advent Calender 23日目の記事です。

普段はWeb周りの技術を扱ってばかりなので、
今回は以前から興味があったUnityを触ってみました。

この記事は、

なんでもいいから一度Unityを使ってプロジェクトを作ってみたい。

という方向けに、プロジェクトの作成からBuildまでの流れを掴んでもらう為に書いたものです。
ですので、数あるUnity機能の中からほんの数個ピックアップして追加したのみにすぎません。
ご了承ください。

目次

1. イントール
2. プロジェクトの作成
3. レイアウトの変更
4. オブジェクトの作成
5. オブジェクトに装飾
6. オブジェクトに動きを与える
7. プロジェクトをBuild

1. イントール

まずはUnityをダウンロードしましょう。
個人開発であれば無料です。
→ ダウンロード画面へ
(*途中のアカウント作成等は割愛させていただきます。)

2. プロジェクトの作成

インストールしたApplicationを開くと以下の画面が現れるので、Newを選択します。

Template を 3D にしてプロジェクトを作成します。

3. レイアウトの変更

こちらがプロジェクトのデフォルト画面です。

自分の作業しやすいレイアウトに変更してください。
私は2by3にしています。

4. オブジェクトを作成

ゲームオブジェクト(以下オブジェクト)を作成します。
Hierarchy → Create → 3Dオブジェクト → Cube の順で選択してください。

すると画面左のSceneにCubeが現れます。

オブジェクトの形を変えるために画面右上のInspectorを下記のように編集します。

オブジェクトの形が変わりました。

この調子で Squareも追加してみます。

5. オブジェクトに装飾

CubeとSquareに色を与えましょう

Project → Materialsを選択

画面を見やすくするために 右上設定(三本の棒線)からOne Column Layoutを選択します。

Material内のスポイトのようなアイコンから色を選択します。

この調子でもう１色作成します。

そして、今作成したMaterialは対象のオブジェクトにドラッグ＆ドロップできます。
(Scene, Hierarchyどちらでも可)

6. オブジェクトに動きを加える

次はSquareに動きをつけられるようにします。

まず、SquareのInspectorからRigidBody(オブジェクトに重力を付与)を追加します。

次に、Add Componentを選択します。
最下部にあるNew Scripを選択、名前を決めてScriptを作成します。

作成されたScriptをダブルクリックするとEditorが開くはずです。

以下、カーソルを押した方向にSquareを動かすようにするScriptです。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class moveScriot : MonoBehaviour
{
    Rigidbody rigidbody;

    // Start is called before the first frame update
    void Start()
    {
        rigidbody = GetComponent<Rigidbody>();
    }

    // Update is called once per frame
    void Update()
    {
        float moveH = Input.GetAxis("Horizontal");
        float moveV = Input.GetAxis("Vertical");
        Vector3 move = new Vector3(moveH, 0, moveV);
        rigidbody.AddForce(move);
    }
}

これでSquareが動くようになったと思います。

画面左下に見えているGameが実際にユーザーがゲームを遊ぶときの視点です。
わかりやすくするために、Main CameraのTransFormを調整してください。

7. プロジェクトをBuildする

最後にこのプロジェクトをBuildしてみましょう。

File → Build Settingsを選択

こちらでプラットフォームを選択することができます。
今回はMacOSのまま進むのでPlatformはそのままで問題ありません。
右上のAdd Open Souceから現在のScenesを追加して、
最後にBuildを選択してください。

デスクトップに作成したゲームが出現します。

これでいつでも先程のGameを開くことができるようになりました。

最近のOculusQuestさんちょっと攻めすぎですよね。
OculusLinkのβが出たのもつい最近な気がしているのに、さらにハンドトラッキングまで！！！

そして、2019/12/20にはUnityのAssetStoreにハンドトラッキング対応のSDKが配布されました。　高速感！

導入方法なんかについては他の方の記事にお任せして・・・。

肝はOVRSkelton

OVRHand には GetFingerIsPinching() と GetFingerPinchStrength() があり、それぞれ、ピンチ（つまんでいる）状態かどうかと
つまんでいる力（距離？）が取得できるメソッドが入っています。
参考：OculusQuestのハンドトラッキングについて色々調べてみた

しかし、ぱっと見たところそれ以外の情報取得がそんなにありません。

そこで上記記事でも言及していますが、もっと詳しい情報を知りたい場合は OVRSkelton.Bones にボーン情報が入っている のでそれを使うことにします。

というのも

僕がやりたかったのは以前作った 「空中に図形を描いて物体を生成するアプリを作ってみた」 のハンドトラッキング版だったので、空中に絵を描くイメージです。
みなさんが空中に絵を描く（例えば、誰かに「＊＊って漢字どう書くんだったっけ？」と聞かれた）時に指をどんな形にするかっていうと

十中八九←これですよね

この「人差し指だけを伸ばして、他曲げている」をGetFingerIsPinching()やGetFingerPinchStrength()でやるのはちょっと無理があります。（できなくはないと思いますが）

そこで、 OVRSkelton.Bones から情報を抜き出して簡単に分析することにしました。

Bone情報取得

OVRSkelton.Bones は IList(Readonly)で、何番目にどの情報が入っているかは以下のようにenumで宣言されています。

    public enum BoneId
    {
        Invalid                 = OVRPlugin.BoneId.Invalid,

        Hand_Start              = OVRPlugin.BoneId.Hand_Start,
        Hand_WristRoot          = OVRPlugin.BoneId.Hand_WristRoot,          // root frame of the hand, where the wrist is located
        Hand_ForearmStub        = OVRPlugin.BoneId.Hand_ForearmStub,        // frame for user's forearm
        Hand_Thumb0             = OVRPlugin.BoneId.Hand_Thumb0,             // thumb trapezium bone
        Hand_Thumb1             = OVRPlugin.BoneId.Hand_Thumb1,             // thumb metacarpal bone
        Hand_Thumb2             = OVRPlugin.BoneId.Hand_Thumb2,             // thumb proximal phalange bone
        Hand_Thumb3             = OVRPlugin.BoneId.Hand_Thumb3,             // thumb distal phalange bone
        Hand_Index1             = OVRPlugin.BoneId.Hand_Index1,             // index proximal phalange bone
        Hand_Index2             = OVRPlugin.BoneId.Hand_Index2,             // index intermediate phalange bone
        Hand_Index3             = OVRPlugin.BoneId.Hand_Index3,             // index distal phalange bone
        Hand_Middle1            = OVRPlugin.BoneId.Hand_Middle1,            // middle proximal phalange bone
        Hand_Middle2            = OVRPlugin.BoneId.Hand_Middle2,            // middle intermediate phalange bone
        Hand_Middle3            = OVRPlugin.BoneId.Hand_Middle3,            // middle distal phalange bone
        Hand_Ring1              = OVRPlugin.BoneId.Hand_Ring1,              // ring proximal phalange bone
        Hand_Ring2              = OVRPlugin.BoneId.Hand_Ring2,              // ring intermediate phalange bone
        Hand_Ring3              = OVRPlugin.BoneId.Hand_Ring3,              // ring distal phalange bone
        Hand_Pinky0             = OVRPlugin.BoneId.Hand_Pinky0,             // pinky metacarpal bone
        Hand_Pinky1             = OVRPlugin.BoneId.Hand_Pinky1,             // pinky proximal phalange bone
        Hand_Pinky2             = OVRPlugin.BoneId.Hand_Pinky2,             // pinky intermediate phalange bone
        Hand_Pinky3             = OVRPlugin.BoneId.Hand_Pinky3,             // pinky distal phalange bone
        Hand_MaxSkinnable       = OVRPlugin.BoneId.Hand_MaxSkinnable,
        // Bone tips are position only. They are not used for skinning but are useful for hit-testing.
        // NOTE: Hand_ThumbTip == Hand_MaxSkinnable since the extended tips need to be contiguous
        Hand_ThumbTip           = OVRPlugin.BoneId.Hand_ThumbTip,           // tip of the thumb
        Hand_IndexTip           = OVRPlugin.BoneId.Hand_IndexTip,           // tip of the index finger
        Hand_MiddleTip          = OVRPlugin.BoneId.Hand_MiddleTip,          // tip of the middle finger
        Hand_RingTip            = OVRPlugin.BoneId.Hand_RingTip,            // tip of the ring finger
        Hand_PinkyTip           = OVRPlugin.BoneId.Hand_PinkyTip,           // tip of the pinky
        Hand_End                = OVRPlugin.BoneId.Hand_End,

        // add new bones here

        Max                     = OVRPlugin.BoneId.Max
    }

親指:Thumb
人差し指:Index
中指:Middle
薬指:Ring
小指:Pinky

で、1,2,3 は関節を表しており、数字が大きくなるほど指先に近づいていく ようです。
僕は英語をロクに読まず 「第一関節」= 1 だと思い込んで処理を書いていたらさっぱり正しい値が返ってこなくてハテ？　となりました。ご注意を・・・。
そして、 Tip とついているのは指先です。

分かりやすくマッピングしてみると、どうもこんな感じ・・・？

なお、Pinky と Thumb だけ 0番があります。

そして、この Bone には Transform が入っており、位置や回転が取れそうです。
例えば「人差し指の先端の位置」を取るには

var indexTipPos = skeleton.Bones[(int) OVRSkeleton.BoneId.Hand_IndexTip].Transform.position;

こうなります（注：enumなのでintキャストが必要)

直線判定

以上を踏まえ、この「人差し指がまっすぐになっていて、中指、薬指、小指は曲がっている」を判定します。（親指は除きました。）

この「人差し指がまっすぐになっている」というのは人差し指の「第三関節→第二関節」の方向（ベクトル）と、「第二関節→第一関節」の方向(ベクトル）と「第一関節→指先」の方向(ベクトル）が大体同じ方向を向いている ということです。

この「二つのベクトルが大体同じ方向を向いている」＝「どれぐらい似通っているか」を表すのは。そう内積(Vector3.Dot)です。

ベクトルの内積は直角（一番似通っていない)な場合は０
全く同じ場合は+1
全く逆方向の場合は-1です

これを人差し指だけではなく他の指の分もベタ書きするとそこそこ長くなってしまうので、以下のようなメソッドを用意すると便利だと思います。

        [SerializeField]
        private OVRSkeleton _skeleton; //右手、もしくは左手の Bone情報

        /// <summary>
        /// 指定した全てのBoneIDが直線状にあるかどうか調べる
        /// </summary>
        /// <param name="threshold">閾値 1に近いほど厳しい</param>
        /// <param name="boneids"></param>
        /// <returns></returns>
        private bool IsStraight(float threshold, params OVRSkeleton.BoneId[] boneids)
        {
            if (boneids.Length < 3) return false;   //調べようがない
            Vector3? oldVec = null;
            var dot = 1.0f;
            for (var index = 0; index < boneids.Length-1; index++)
            {
                var v = (_skeleton.Bones[(int)boneids[index+1]].Transform.position - _skeleton.Bones[(int)boneids[index]].Transform.position).normalized;
                if (oldVec.HasValue)
                {
                    dot *= Vector3.Dot(v, oldVec.Value); //内積の値を総乗していく
                }
                oldVec = v;//ひとつ前の指ベクトル
            }
            return dot >= threshold; //指定したBoneIDの内積の総乗が閾値を超えていたら直線とみなす
        }

可変長配列でBoneIDを複数(3個以上)受けとり、一つ前のBoneIDが示す関節から関節のベクトルと、今のBoneIDが示す関節と次の関節のベクトルの内積を計算して、 dot にどんどん乗算していっています。（別に平均でも良い気はしますが）

これを使うと、人差し指がまっすぐかどうかを判定してLogに表示する場合、このようになります。

var isIndexStraight = IsStraight(0.8f, OVRSkeleton.BoneId.Hand_Index1, OVRSkeleton.BoneId.Hand_Index2, OVRSkeleton.BoneId.Hand_Index3, OVRSkeleton.BoneId.Hand_IndexTip);
Debug.Log($"人差し指は{isIndexStraight?"まっすぐ":"曲がってる"}");

おなじく、他の指も調べていけば、「人差し指がまっすぐになっていて、中指、薬指、小指は曲がっている」は判定できそうです。

var isIndexStraight = IsStraight(0.8f, OVRSkeleton.BoneId.Hand_Index1, OVRSkeleton.BoneId.Hand_Index2, OVRSkeleton.BoneId.Hand_Index3, OVRSkeleton.BoneId.Hand_IndexTip);
var isMiddleStraight = IsStraight(0.8f, OVRSkeleton.BoneId.Hand_Middle1, OVRSkeleton.BoneId.Hand_Middle2, OVRSkeleton.BoneId.Hand_Middle3, OVRSkeleton.BoneId.Hand_MiddleTip);
var isRingStraight = IsStraight(0.8f, OVRSkeleton.BoneId.Hand_Ring1, OVRSkeleton.BoneId.Hand_Ring2, OVRSkeleton.BoneId.Hand_Ring3, OVRSkeleton.BoneId.Hand_RingTip);
var isPinkyStraight = IsStraight(0.8f, OVRSkeleton.BoneId.Hand_Pinky0, OVRSkeleton.BoneId.Hand_Pinky1, OVRSkeleton.BoneId.Hand_Pinky2, OVRSkeleton.BoneId.Hand_Pinky3, OVRSkeleton.BoneId.Hand_PinkyTip);

Debug.Log($"人差し指は{isIndexStraight?"まっすぐ":"曲がってる"}");
Debug.Log($"中指は{isMiddleStraight?"まっすぐ":"曲がってる"}");
Debug.Log($"薬指は{isRingStraight?"まっすぐ":"曲がってる"}");
Debug.Log($"小指は{isPinkyStraight?"まっすぐ":"曲がってる"}");

if(isIndexStraight && !isMiddleStraight  && !isRingStraight  && !isPinkyStraight ){ //人差し指だけまっすぐで、その他が曲がっている
    Debug.Log($"お前がナンバーワンだ！");
}

そして、人差し指の先端の位置 (IndexTip) で線を描くとこうなりました

実家に帰っている間にOculusQuestのハンドトラッキングがUnity対応していたので、色々と試し中。
左手がボーンだけ表示。
ボーンから関節情報が取れるので、各指が伸びているか曲がっているかを独自に計算してみた。
しかし・・・。座標が安定しないので全然図形は描けない。ぐぬぬ。#OculusQuest pic.twitter.com/6PaNVLBfmh

— すずきかつーき (@divideby_zero) December 22, 2019

うーん。　ノイズなのかなんなのか。　まったく直線が描けてないですね。

とりあえずの目標（で線を描く）はできているので、よしとします。
この問題はまた後日・・・。

まとめ

OVRHandからとれるピンチ情報に加え、この「各指が曲がっているか(false)伸びているか(true)」が加わるだけでもいろんな事が出来るんじゃないかなと思います。
<例>
- 全部falseならグー、人差し指と中指だけtrueならチョキ、全部trueならパー、でじゃんけん
- 中指と小指がfalse、そのほかがtrueで「グワシ！」
- 中指だけtrue そのほかfalse で 「F******!」で、プログラム強制終了。
などなど。

しかし・・。ちゃんとリファレンス見てないので、こんなことしなくても情報は取れるよ！もっといい方法あるよ！　などあったらコメント教えてください。

ではでは、よきOculusQuestライフを。