DEV Community: 松本隆介

MagicLeapのEyeトラッキングの使い方( 超簡単サンプル )

松本隆介 — Sun, 04 Oct 2020 10:05:51 +0000

開発環境

SDK等	バージョン
OS	Windows10
Unity	2019.3.7f1
LuminOS	0.98.11
LuminSDK	0.24.1
MagicLeap-ToolKit	2020/09/27時点での最新( 特にバージョン表記がない為 )

サンプル動画

Eyeトラッキングのチョットしたサンプル作ってみた pic.twitter.com/C8afUckEHO
— 松本隆介 (@matsumotokaka11) October 1, 2020

なおこのサンプルはアプリの停止処理を入れてないので別途導入するか或いはThe Labからアプリを停止することをお勧めします

今回のサンプルはこちらのリポジトリ、EyeTrackingシーンに作成してあります

シーン構成

今回は超簡単サンプルということでシーンの構成も簡単にしました

スクリプト

今回のサンプルでは右目の目線の先に青いキューブ、左目の目線の先に赤いキューブを配置し、瞬きしたら効果音を鳴らすサンプルです

using UnityEngine;
using UnityEngine.XR.MagicLeap;

namespace EyeTracking
{
    public class EyeTrackingSample : MonoBehaviour
    {
        readonly float TargetDistance = 2f;

        [SerializeField] Transform leftEyeTarget;
        [SerializeField] Transform rightEyeTarget;
        [SerializeField] AudioSource audioSource;
        [SerializeField] AudioClip blinkSound;


        void Start()
        {
            MLEyes.Start();
        }


        void OnDestroy()
        {
            MLEyes.Stop();
        }


        void Update()
        {
            if (!MLEyes.IsStarted) return;

            switch (MLEyes.CalibrationStatus)
            {
                case MLEyes.Calibration.Bad:
                    leftEyeTarget.gameObject.SetActive(false);
                    rightEyeTarget.gameObject.SetActive(false);
                    break;

                case MLEyes.Calibration.Good:
                    leftEyeTarget.gameObject.SetActive(true);
                    rightEyeTarget.gameObject.SetActive(true);
                    leftEyeTarget.position = MLEyes.LeftEye.Center + (MLEyes.LeftEye.ForwardGaze.normalized * TargetDistance);
                    rightEyeTarget.position = MLEyes.RightEye.Center + (MLEyes.RightEye.ForwardGaze.normalized * TargetDistance);

                    if ((MLEyes.LeftEye.IsBlinking || MLEyes.RightEye.IsBlinking) && !audioSource.isPlaying)
                        audioSource.PlayOneShot(blinkSound);
                    break; 

                case MLEyes.Calibration.None:
                    leftEyeTarget.gameObject.SetActive(false);
                    rightEyeTarget.gameObject.SetActive(false);
                    break;
            }

        }
    }
}

コードの解説

Start()にあるMLEyes.Start()でEyeトラッキング用のモジュールを起動します

void Start()
{
    MLEyes.Start();
}

OnDestroy()でモジュールを停止します

void OnDestroy()
{
    MLEyes.Stop();
}

メインの処理はこちらになります
Update()では一応モジュールが起動していない場合は処理をスキップするようにしておきます

void Update()
{
    if (!MLEyes.IsStarted) return;

    switch (MLEyes.CalibrationStatus)
    {
        case MLEyes.Calibration.Bad:
            leftEyeTarget.gameObject.SetActive(false);
            rightEyeTarget.gameObject.SetActive(false);
            break;

        case MLEyes.Calibration.Good:
            leftEyeTarget.gameObject.SetActive(true);
            rightEyeTarget.gameObject.SetActive(true);
            leftEyeTarget.position = MLEyes.LeftEye.Center + (MLEyes.LeftEye.ForwardGaze.normalized * TargetDistance);
            rightEyeTarget.position = MLEyes.RightEye.Center + (MLEyes.RightEye.ForwardGaze.normalized * TargetDistance);
            if ((MLEyes.LeftEye.IsBlinking || MLEyes.RightEye.IsBlinking) && !audioSource.isPlaying)
                audioSource.PlayOneShot(blinkSound);
            break; 

        case MLEyes.Calibration.None:
            leftEyeTarget.gameObject.SetActive(false);
            rightEyeTarget.gameObject.SetActive(false);
            break;
    }

}

目のキャリブレーションの状態が悪い時とそもそものキャリブレーションが取れていないときはターゲットとなるオブジェクトを非表示にしています
キャリブレーションが取れている場合は左右それぞれの目の正面方向( 今回は2m前方 )にオブジェクトを配置し、瞬きをしたら効果音を再生するようにしています

if ((MLEyes.LeftEye.IsBlinking || MLEyes.RightEye.IsBlinking) && !audioSource.isPlaying)
    audioSource.PlayOneShot(blinkSound);

勘のいいひとはこれで気づくかもしれませんが瞬きの判定は瞬きした瞬間ではなく瞼を閉じている間になっています、そのため効果音を再生中は効果音を再生しないようにして多重に再生されるのを防いでいます
しばらく目をつぶっているとキャリブレーションの判定がNoneに遷移して処理がスキップされるようになります

簡単なMLEyes周りの紹介

MLEyesは左右の目の情報を管理するクラスです、これ自体はシングルトンクラスなのでインスタンス化の必要はなく左右それぞれの目へのアクセスも

MLEyes.LeftEye
MLEyes.RightEye

このメンバーでアクセスが可能です

アイトラッキングのキャリブレーションの状態は以下のようにアクセスできます


switch (MLEyes.CalibrationStatus)
{
    case MLEyes.Calibration.Bad:
        // キャリブレーションの状態が悪い.
        break;

    case MLEyes.Calibration.Good:
        // キャリブレーションの状態が良好.
        break; 

    case MLEyes.Calibration.None:
        // キャリブレーションできていない.
        break;
}

API Referenceにはこのように記述されています

~~The Labから見られるAPIのドキュメントバージョンが更新されていないのかMLEyeについての情報が手探りですが簡単な紹介を以下にしておきます~~

API Referenceを参照したい場合はDeveloper Portalの方を参照したほうがいいですね
尚左目のみ紹介します( 右目のプロパティ等も同様の構成の為 )

MLEyes.LeftEye.Center

目の中心座標

MLEyes.LeftEye.Gaze

目の回転Gazeとありますが視線の方向を撮りたいときは以下のプロパティから取得したほうが直感的です、本サンプルでもこちらを利用しています

MLEyes.LeftEye.ForwardGaze

目のタイプ、右か左かのタイプです
現時点で既にプロパティとしてLeftEye、RightEyeとあるので利用することは無いと思います

MLEyes.LeftEye.Type

アイトラッキングの情報の信頼性
0 で目を閉じているまたはデバイスをかぶっていない、最初の更新時は0で初期化されています

MLEyes.LeftEye.CenterConfidence

瞬きしているか否か、trueで瞬き( どちらかというと瞼を閉じている )の判定になります

MLEyes.LeftEye.IsBlinking

MagicLeapで任意の平面にオブジェクトを置く方法

松本隆介 — Tue, 22 Sep 2020 16:51:03 +0000

ここの記事の続き : MagicLeapで床にオブジェクトを配置する方法

基本的な開発環境やシーンの構成は同じ

開発環境

Unity : 2019.3.7f1

LuminOS : 0.98.11, APILevel 8

MagicLeap : UnitySDK 0.24.1

MagicLeap : ToolKit 特にバージョン表記等はないので現時点(2020/09/23)での最新

MagicLeapToolKitのDLはこちらから

今回開発したアプリのリポジトリはこちら

PlaneCheckシーンにサンプルが配置してあります

完成するもの

任意の平面を判定するやつ pic.twitter.com/bJ8k1Udb5k
— 松本隆介 (@matsumotokaka11) September 22, 2020

下準備

この辺りは前回の記事と同様なので飛ばしても大丈夫です

ProjectSettings > MagicLeap > ManifestSettings

にて以下の項目にチェックを入れました

ControllerPose
LowLatencyLightwear
WorldReconstruction

シーンの構成

基本的には前回とはあまり変わってませんがどの平面を判定しているかを確認するためRuntimeConsoleを新たに追加しました

RuntimeConsoleは

MagicLeap-Tools > Prefabs > Debugging

にあるプレハブをシーン上に配置しています

PlaneCheckerオブジェクトにアタッチしているスクリプトで参照するので紐づけます

スクリプト

前回作成したFloorCheckerをさらに改造したPlaneCheckerを作成します

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

#if PLATFORM_LUMIN
using UnityEngine.XR.MagicLeap;
#endif


namespace PlaneCheck
{
    /// <summary>
    /// MagicLeapToolsのFloorOnPlaceを改造したクラス.
    /// 任意の平面を判定する.
    /// </summary>
    public class PlaneChecker : MonoBehaviour
    {
        readonly float HeadLocationIdleThreshold = 0.003f;
        readonly float HeadRotationIdleThreshold = .3f;
        readonly int HistoryCount = 5;
        readonly float HeadIdleRequiredDuration = .2f;


        public Vector3 Location
        {
            get;
            private set;
        }

        List<Vector3> headLocationHistory;
        List<Quaternion> headRotationHistory;
        float headLocationVelocity;
        float headRotationVelocity;
        Transform mainCamera;
        bool headLocationIdle;
        bool headRotationIdle;
        bool headTemporarilyIdle;
        bool headIdle;
        bool placementValid;


        void Awake()
        {
            mainCamera = Camera.main.transform;

            if (FindObjectOfType<MLSpatialMapper>() == null)
            {
                Debug.LogError("PlaceOnFloor requires and instance of the MLSpatialMapper in your scene.");
            }
        }


        void OnEnable()
        {
            headLocationHistory = new List<Vector3>();
            headRotationHistory = new List<Quaternion>();
        }


        void Update()
        {
            if (Time.frameCount < 3)
            {
                return;
            }

            HeadActivityDetermination(); 
        }


        IEnumerator HeadIdleTimeout()
        {
            yield return new WaitForSeconds(HeadIdleRequiredDuration);
            headIdle = true;
        }


        void HeadActivityDetermination()
        {
            //history:
            headLocationHistory.Add(mainCamera.position);
            if (HistoryCount < headLocationHistory.Count)
                headLocationHistory.RemoveAt(0);

            headRotationHistory.Add(mainCamera.rotation);
            if (HistoryCount < headRotationHistory.Count)
                headRotationHistory.RemoveAt(0);

            //location velocity:
            if (headLocationHistory.Count == HistoryCount)
            {
                headLocationVelocity = 0;
                for (int i = 1; i < headLocationHistory.Count; i++)
                {
                    headLocationVelocity += Vector3.Distance(headLocationHistory[i], headLocationHistory[i - 1]);
                }
                headLocationVelocity /= headLocationHistory.Count;

                //idle detection:
                if (headLocationVelocity <= HeadLocationIdleThreshold)
                {
                    if (!headLocationIdle)
                    {
                        headLocationIdle = true;
                    }
                }
                else
                {
                    if (headLocationIdle)
                    {
                        headLocationIdle = false;
                    }
                }
            }

            //rotation velocity:
            if (headRotationHistory.Count == HistoryCount)
            {
                headRotationVelocity = 0;
                for (int i = 1; i < headRotationHistory.Count; i++)
                {
                    headRotationVelocity += Quaternion.Angle(headRotationHistory[i], headRotationHistory[i - 1]);
                }
                headRotationVelocity /= headRotationHistory.Count;

                //idle detection:
                if (headRotationVelocity <= HeadRotationIdleThreshold)
                {
                    if (!headRotationIdle)
                    {
                        headRotationIdle = true;
                    }
                }
                else
                {
                    if (headRotationIdle)
                    {
                        headRotationIdle = false;
                    }
                }
            }

            //absolute idle head determination:
            if (headLocationIdle && headRotationIdle)
            {
                if (!headTemporarilyIdle)
                {
                    headTemporarilyIdle = true;
                    StartCoroutine(HeadIdleTimeout());
                }
            }
            else
            {
                if (headTemporarilyIdle)
                {
                    headIdle = false;
                    headTemporarilyIdle = false;
                    StopCoroutine(HeadIdleTimeout());
                }
            }
        }


        /// <summary>
        /// 指定したRayの位置に任意の面があるか否か、ある場合はその座標も返す.
        /// </summary>
        /// <param name="ray"></param>
        /// <param name="surfaceType"></param>
        /// <returns></returns>
        public (bool, Vector3) LookingAtFloorDetermination(
            Ray ray,
            MagicLeapTools.SurfaceType surfaceType)
        {
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit))
            {
                MagicLeapTools.SurfaceType surface = MagicLeapTools.SurfaceDetails.Analyze(hit);

                if (surface == surfaceType)
                {
                    Location = hit.point;
                    placementValid = true;
                    return (true, Location);
                }
                else
                {
                    placementValid = false;
                    return (false, Vector3.zero);
                }
            }
            else
            {
                placementValid = false;
                return (false, Vector3.zero);
            }
        }


    }
}

この部分で任意の平面かの判定をとっています

        /// <summary>
        /// 指定したRayの位置に任意の面があるか否か、ある場合はその座標も返す.
        /// </summary>
        /// <param name="ray"></param>
        /// <param name="surfaceType"></param>
        /// <returns></returns>
        public (bool, Vector3) LookingAtFloorDetermination(
            Ray ray,
            MagicLeapTools.SurfaceType surfaceType)
        {
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit))
            {
                MagicLeapTools.SurfaceType surface = MagicLeapTools.SurfaceDetails.Analyze(hit);

                if (surface == surfaceType)
                {
                    Location = hit.point;
                    placementValid = true;
                    return (true, Location);
                }
                else
                {
                    placementValid = false;
                    return (false, Vector3.zero);
                }
            }
            else
            {
                placementValid = false;
                return (false, Vector3.zero);
            }
        }

判定することが出来る平面はMagicLeapToolsのSurfaceDetils.csに定義されています

今回のサンプルでは床、壁、天井の三種類を判定することにしました

PlaneCheckerを利用するPlaneCheckOnPlaceContent.cs

基本的な構成は前回のFloorCheckOnPlaceContent.csとあまり変わっていません

Bumperボタンを押下したら判定を切り替えるようにしています

ControlPointerオブジェクトのControlInputにOnBumperButtonDown()を登録

using MagicLeapTools;
using UnityEngine;

namespace PlaneCheck
{

    /// <summary>
    /// トリガを入力したときに任意の平面を判定し、床の場合はオブジェクトを配置するサンプル.
    /// </summary>
    [RequireComponent(typeof(PlaneChecker),typeof(AudioSource))]
    public class PlaneCheckOnPlaceContent : MonoBehaviour
    {

        [SerializeField] AudioClip pressClip;
        [SerializeField] AudioClip successClip;
        [SerializeField] AudioClip failedClip;
        [SerializeField] GameObject content;
        [SerializeField] Pointer pointer;
        [SerializeField] RuntimeConsole runtimeConsole;
        PlaneChecker planeChecker;
        AudioSource audio;
        SurfaceType[] surfaceTypes;
        int index = 0;

        void Start()
        {
            planeChecker = GetComponent<PlaneChecker>();
            audio = GetComponent<AudioSource>();

            // RuntimeConsoleに自分が指定した文字列だけ表示したい.
            runtimeConsole.errors = false;
            runtimeConsole.logs = false;
            runtimeConsole.warnings = false;

            // 今回はこの三種類のみをチェック.
            surfaceTypes = new[]
            {
                SurfaceType.Floor,   // 床.
                SurfaceType.Wall,    // 壁.
                SurfaceType.Ceiling, // 天井.
            };
        }


        public void OnBumperButtonDown()
        {
            index = (int)Mathf.Repeat(index + 1, surfaceTypes.Length);
            runtimeConsole.logText.text = surfaceTypes[index].ToString();
        }


        public void OnTriggerDown()
        {
            audio.PlayOneShot(pressClip);
            (bool onSurfaceType, Vector3 pos ) result = planeChecker.LookingAtFloorDetermination(new Ray(pointer.Origin, pointer.Direction), surfaceTypes[index]);
            if (result.onSurfaceType)
            {
                audio.PlayOneShot(successClip);
                content.transform.position = result.pos;
            }
            else
            {
                audio.PlayOneShot(failedClip);
            }
        }



    }
}

完成

これでデプロイ or ZeorIterationで確認すれば↓の様な動作になります

ただしRuntimeConsoleは実機にデプロイ時にしか動作しないので実機での確認のほうがどの平面を判定しているかがわかりやすいです

任意の平面を判定するやつ pic.twitter.com/bJ8k1Udb5k
— 松本隆介 (@matsumotokaka11) September 22, 2020

感想

これで任意の平面にオブジェクトを配置したりできるようになりました

なんか家具の配置確認アプリ的なもので天井にランプをつるすとか、壁に絵を飾るとかの確認に使うのがメイン所の使い方かな?

MagicLeapで床にオブジェクトを配置する方法

松本隆介 — Mon, 21 Sep 2020 19:03:39 +0000

開発環境

Unity : 2019.3.7f1
LuminOS : 0.98.11, APILevel 8
MagicLeap : UnitySDK 0.24.1
MagicLeap : ToolKit 特にバージョン表記等はないので現時点(2020/09/22)での最新

MagicLeapToolKitのDLはこちらから

今回開発したアプリのリポジトリはこちら
FloorCheckシーンにサンプルが配置してあります

完成するもの

床を判定するやつ pic.twitter.com/zzhb4lk5g2
— 松本隆介 (@matsumotokaka11) September 21, 2020

下準備

ProjectSettings > MagicLeap > ManifestSettings

にて以下の項目にチェックを入れました

ControllerPose
LowLatencyLightwear
WorldReconstruction

スクリプト等

今回のスクリプトはMagicLeap ToolKitのPlaceOnFloorを改造したものです

素のPlaceOnFloorのままだと初回の床判定以降は床判定を行わないので何度でも床判定を行えるようにしました。

改造したFloorChecker.cs


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

#if PLATFORM_LUMIN
using UnityEngine.XR.MagicLeap;
#endif


namespace FloorCheck
{
    /// <summary>
    /// MagicLeapToolsのFloorOnPlaceを改造したクラス.
    /// 床検知を何度もにできるようにする.
    /// </summary>
    public class FloorChecker : MonoBehaviour
    {
        readonly float HeadLocationIdleThreshold = 0.003f;
        readonly float HeadRotationIdleThreshold = .3f;
        readonly int HistoryCount = 5;
        readonly float HeadIdleRequiredDuration = .2f;

        // Public Properties:
        public Vector3 Location
        {
            get;
            private set;
        }


        [Tooltip("Does content's content match it's transform forward?")]
        [SerializeField] bool flippedForward;


        List<Vector3> headLocationHistory;
        List<Quaternion> headRotationHistory;
        float headLocationVelocity;
        float headRotationVelocity;
        Transform mainCamera;
        bool headLocationIdle;
        bool headRotationIdle;
        bool headTemporarilyIdle;
        bool headIdle;
        bool placementValid;


        //Init:
        void Awake()
        {
            //refs:
            mainCamera = Camera.main.transform;

            //requirements:
            if (FindObjectOfType<MLSpatialMapper>() == null)
            {
                Debug.LogError("PlaceOnFloor requires and instance of the MLSpatialMapper in your scene.");
            }
        }


        //Flow:
        void OnEnable()
        {
            //sets:
            headLocationHistory = new List<Vector3>();
            headRotationHistory = new List<Quaternion>();
        }


        //Loops:
        void Update()
        {
            //let headpose warmup a little:
            if (Time.frameCount < 3)
            {
                return;
            }

            HeadActivityDetermination(); 
        }


        //Coroutines:
        IEnumerator HeadIdleTimeout()
        {
            yield return new WaitForSeconds(HeadIdleRequiredDuration);
            headIdle = true;
        }


        void HeadActivityDetermination()
        {
            //history:
            headLocationHistory.Add(mainCamera.position);
            if (HistoryCount < headLocationHistory.Count)
                headLocationHistory.RemoveAt(0);

            headRotationHistory.Add(mainCamera.rotation);
            if (HistoryCount < headRotationHistory.Count)
                headRotationHistory.RemoveAt(0);

            //location velocity:
            if (headLocationHistory.Count == HistoryCount)
            {
                headLocationVelocity = 0;
                for (int i = 1; i < headLocationHistory.Count; i++)
                {
                    headLocationVelocity += Vector3.Distance(headLocationHistory[i], headLocationHistory[i - 1]);
                }
                headLocationVelocity /= headLocationHistory.Count;

                //idle detection:
                if (headLocationVelocity <= HeadLocationIdleThreshold)
                {
                    if (!headLocationIdle)
                    {
                        headLocationIdle = true;
                    }
                }
                else
                {
                    if (headLocationIdle)
                    {
                        headLocationIdle = false;
                    }
                }
            }

            //rotation velocity:
            if (headRotationHistory.Count == HistoryCount)
            {
                headRotationVelocity = 0;
                for (int i = 1; i < headRotationHistory.Count; i++)
                {
                    headRotationVelocity += Quaternion.Angle(headRotationHistory[i], headRotationHistory[i - 1]);
                }
                headRotationVelocity /= headRotationHistory.Count;

                //idle detection:
                if (headRotationVelocity <= HeadRotationIdleThreshold)
                {
                    if (!headRotationIdle)
                    {
                        headRotationIdle = true;
                    }
                }
                else
                {
                    if (headRotationIdle)
                    {
                        headRotationIdle = false;
                    }
                }
            }

            //absolute idle head determination:
            if (headLocationIdle && headRotationIdle)
            {
                if (!headTemporarilyIdle)
                {
                    headTemporarilyIdle = true;
                    StartCoroutine(HeadIdleTimeout());
                }
            }
            else
            {
                if (headTemporarilyIdle)
                {
                    headIdle = false;
                    headTemporarilyIdle = false;
                    StopCoroutine(HeadIdleTimeout());
                }
            }
        }


        /// <summary>
        /// 指定したRayの位置に床があるか否か、ある場合はその座標も返す.
        /// </summary>
        /// <param name="ray"></param>
        /// <returns></returns>
        public (bool, Vector3) LookingAtFloorDetermination(
            Ray ray)
        {
            //cast to see if we are looking at the floor:
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit))
            {
                MagicLeapTools.SurfaceType surface = MagicLeapTools.SurfaceDetails.Analyze(hit);

                if (surface == MagicLeapTools.SurfaceType.Floor)
                {
                    Location = hit.point;
                    placementValid = true;
                    return (true, Location);
                }
                else
                {
                    placementValid = false;
                    return (false, Vector3.zero);
                }
            }
            else
            {
                placementValid = false;
                return (false, Vector3.zero);
            }
        }


    }
}

FloorCheckerを利用するFloorCheckOnPlaceContent.cs

using System;
using MagicLeapTools;
using UnityEngine;

namespace FloorCheck
{

    /// <summary>
    /// トリガを入力したときに床を判定し、床の場合はオブジェクトを配置するサンプル.
    /// </summary>
    [RequireComponent(typeof(FloorChecker),typeof(AudioSource))]
    public class FloorCheckOnPlaceContent : MonoBehaviour
    {

        [SerializeField] AudioClip pressClip;
        [SerializeField] AudioClip successClip;
        [SerializeField] AudioClip failedClip;
        [SerializeField] GameObject content;
        [SerializeField] Pointer pointer;
        FloorChecker floorChecker;
        AudioSource audio;


        void Start()
        {
            floorChecker = GetComponent<FloorChecker>();
            audio = GetComponent<AudioSource>();
        }


        public void OnTriggerDown()
        {
            audio.PlayOneShot(pressClip);
            (bool onFloor, Vector3 pos ) result = floorChecker.LookingAtFloorDetermination(new Ray(pointer.Origin, pointer.Direction));
            if (result.onFloor)
            {
                audio.PlayOneShot(successClip);
                content.transform.position = result.pos;
            }
            else
            {
                audio.PlayOneShot(failedClip);
            }
        }



    }
}

シーンの構成

シーンの構成は以下の画像の通りになっています

MainCameraは

Assets > MagicLeap > Core > Assets > Prefabs

にある物を使いました

ControlPointerは

Assets > MagicLeap-Tools > Prefabs > Input

から

今回はSpatialMapperを表示してどのメッシュの判定が通っているかをわかりやすくするので

Assets > MagicLeap > Core > Assets > Prefabs

のMLSpatialMapperも利用します

MLSpatialMapperにはメッシュを生成するルートとなるオブジェクトが必要なのでシーン上にMeshRootオブジェクトを作成しそれをあてがっています

FloorCheckerを利用するクラス等はこのような構成になります
効果音は魔王魂さんから拝借

トリガ入力に対応して床判定を行うためにControlPointerのイベントにFloorCheckOnPlaceContentのOnTriggerDownを登録しています

完成

実機にビルド or ZeroIterationで動作確認をすれば

床を判定するやつ pic.twitter.com/zzhb4lk5g2
— 松本隆介 (@matsumotokaka11) September 21, 2020

これで床を判定し、床だけに配置したいオブジェクトとかの実装ができるようになります

感想

この判定を使えば床判定の入ってるメッシュだけAgentのNavMeshを晴れたりできるかも?

まだやってない、出来たら記事にするかもしれません

Unityエディタ拡張 Drag & Drop 領域をちょっと便利にする ( 備忘録 )

松本隆介 — Fri, 11 Sep 2020 20:22:32 +0000

個人的に便利なDrag & Dropのエディタ拡張をメモ

完成図

完成系はこんな感じです、テスト用にターゲットとする拡張子を変更できるようにしてます。

記事用動画 pic.twitter.com/4FRBhqSanw
— 松本隆介 (@matsumotokaka11) September 11, 2020

スクリプト

using System.IO;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Events;
using UnityEditor;

namespace Sample
{
    public class DragAndDropEditor : EditorWindow
    {
        [MenuItem("Custom/DragAndDropEditor")]
        static void ShowWindow()
        {
            var window = GetWindow<DragAndDropEditor>();
            window.titleContent = new GUIContent("DragAndDropEditor");
        }


        // テスト用.
        StringBuilder stringBuilder = new StringBuilder(512);
        string targetExtension = ".unity";


        // UI描画.
        void OnGUI()
        {
            // テスト用,ターゲットの拡張子を変更する.
            targetExtension = EditorGUILayout.TextField("targetExtension", targetExtension);

            // 目的とするファイルの拡張子を指定してDrag & Dropの領域を描画する.
            // 複数ファイルドロップに対応し、指定した拡張子以外のファイルがマスクされた配列がコールバックで呼ばれる.
            DrawFileDragArea(
                GUILayoutUtility.GetRect(0.0f, 75.0f, GUILayout.ExpandWidth(true)),
                "Drag & Drop",
                targetExtension,
                (objs) =>
                {
                    stringBuilder.Clear();
                    foreach (var obj in objs)
                    {
                        stringBuilder.AppendLine(obj.name);
                    }
                });

            if (GUILayout.Button("Clear"))
            {
                stringBuilder.Clear();
            }

            // 取得したアイテムのリストを描画.
            EditorGUILayout.LabelField(stringBuilder.ToString(), GUILayout.Height(300));
        }


        /// <summary>
        /// ドラッグアンドドロップ領域を描画,コールバックで取得したオブジェクトを得る.
        /// </summary>
        /// <param name="dropArea"> Drag & Dropを受け付ける範囲. </param>
        /// <param name="dropAreaMessage"> Drag & Dropを受け付ける領域に描画する文字列. </param>
        /// <param name="targetFileExtension"> 目的のファイルの拡張子. </param>
        /// <param name="dropCallback"> Dropされた時のコールバック.  </param>
        /// <param name="visualMode"> マウスカーソルの見ため,基本的にGenericでよいと思われる. </param>
        private void DrawFileDragArea(
            Rect dropArea,
            string dropAreaMessage,
            string targetFileExtension,
            UnityAction<UnityEngine.Object[]> dropCallback,
            DragAndDropVisualMode visualMode = DragAndDropVisualMode.Generic)
        {
            Event evt = Event.current;
            GUI.Box(dropArea, dropAreaMessage);

            switch (evt.type)
            {
                // ドラッグ中.
                case EventType.DragUpdated:
                case EventType.DragPerform:
                    if (!dropArea.Contains(evt.mousePosition))  break;

                    // Dragされている間のカーソルの見た目を変更.
                    DragAndDrop.visualMode = visualMode;

                    if (evt.type == EventType.DragPerform)
                    {
                        // オブジェクトを受け入れる.
                        DragAndDrop.AcceptDrag();
                        if (0 < DragAndDrop.objectReferences.Length)
                        {
                            var dropObjects = new List<UnityEngine.Object>();
                            for (var i = 0; i < DragAndDrop.paths.Length; ++i)
                            {
                                if (Path.GetExtension(DragAndDrop.paths[i]) == targetFileExtension)
                                    dropObjects.Add(DragAndDrop.objectReferences[i]);
                            }

                            if (0 < dropObjects.Count)
                                dropCallback?.Invoke(dropObjects.ToArray());
                        }
                        DragAndDrop.activeControlID = 0;
                    }
                    Event.current.Use();
                    break;
            }
        }

    }    
}

VContainer の導入と基本的な使い方 ver 0.9.0 ( 備忘録 )

松本隆介 — Thu, 03 Sep 2020 17:58:56 +0000

自分用の備忘録記事

最近新しくリリースされたシンプルなDIコンテナライブラリのVContainerの導入方法をメモ

環境

Unity 2018.4.14.f1
VContainer ver 0.9.0

導入方法

GitHubから直接UnityPackageをDLしてプロジェクトにインストールする方法とUnityPackageManagerでインストールする方法がある、今回はUnityPackageを直接インストールする方法をとる

GitHubのリリースページから0.9.0のUnityPackageをDLし、プロジェクトにインポート
この時、manifest.jsonに

nuget.mono-cecil": "0.1.6-preview

の指定を追加

これで特にエラーが無ければまずは導入成功

簡単なサンプル

次にVContainerを利用した簡単なサンプルを作成します。
VContainerには疑似的にMonoBehaviourのStartやUpdateイベントと似た様な処理を行うことが出来る仕組みがあるので( MonoBehaviourを利用しないクラスでMonoBehaviourのUpdate同様に毎フレーム何かの処理をする等を行えるように )そのサンプルとMonoBehaviourを継承した通常のGameObjectのコンポーネントから利用する方法の二通りを作成します。

HelloWorldServiceの作成

先ずはゲームを通じて利用するHelloWorldServiceクラスを作成します、呼び出し元確認用にstringで引数をとりいつ呼ばれたかをコンソールに表示します、このクラスはMonoBehaviourを継承しないクラスとします。

using UnityEngine;

public class HelloWorldService
{

    public void HelloWorld(
        string text)
    {
        Debug.Log($"{text} : HelloWorld");
    }

}

GameLifetimeScopeの作成

Zenjectで言うところのSceneContextを作成します
ProjectWindowで右クリック Create > C# Script でファイル名に *LifetimeScopeと記述すると自動でテンプレートスクリプトを作成します。

using VContainer;
using VContainer.Unity;

public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
    }
}

この段階ではまだテンプレートのままです、いったん先に進みます。

GamePresenterの作成

MonoBehaviourを継承していないクラスでMonoBehaviourのStartやUpdateのイベント同様な処理を行えるクラスを作成します。

LifeCycleのイメージ図

using VContainer.Unity;

public class GamePresenter :
    IInitializable,
    IPostInitializable,
    IFixedTickable,
    IPostFixedTickable,
    ITickable,
    IPostTickable,
    ILateTickable,
    IPostLateTickable
{
    private readonly HelloWorldService hellowWorldService;


    public GamePresenter(
        HelloWorldService _helloWOrldService)
    {
        hellowWorldService = _helloWOrldService;
    }


    // Start()直前に呼ばれる.
    public void Initialize()
    {
        hellowWorldService.HelloWorld("Initialize");
    }


    // Start()直後に呼ばれる.
    public void PostInitialize()
    {
        hellowWorldService.HelloWorld("Postinitialize");
    }


    // FixedUpdate()直前に呼ばれる.
    public void FixedTick()
    {
        hellowWorldService.HelloWorld("FixedTick");
    }


    // FixedUpdate()直後に呼ばれる.
    public void PostFixedTick()
    {
        hellowWorldService.HelloWorld("PostFixedTick");
    }


    // Update()直前に呼ばれる.
    public void Tick()
    {
        hellowWorldService.HelloWorld("Tick");
    }


    // Update()直後に呼ばれる.
    public void PostTick()
    {
        hellowWorldService.HelloWorld("PostTick");
    }


    // LateUpdate()直前に呼ばれる.
    public void LateTick()
    {
        hellowWorldService.HelloWorld("LateTick");
    }


    // LateUpdate()直後に呼ばれる.
    public void PostLateTick()
    {
        hellowWorldService.HelloWorld("PostLateTick");
    }

}

実装しているインターフェースは其々コメントに書かれある通りのタイミングに呼ばれます。

TestObjectの作成

最後にMonoBehaviourを継承したTestObjectクラスを作成します

using UnityEngine;
using VContainer;

public class TestObject : MonoBehaviour
{
    private HelloWorldService helloWorldService;


    // コンテナから取得.
    [Inject]
    public void Construct(HelloWorldService _helloWorldService)
    {
        Debug.Log("Inject");
        helloWorldService = _helloWorldService;
    }


    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            helloWorldService.HelloWorld("TestObject");
        }
    }
}

Update時にスペースキーを押下したらHelloWorldSericeのHelloWorld()を呼び出すようにします。

Sceneの作成

次にシーンを作成します
先ずコンテナを実装するためにGameLifetimeScopeオブジェクトを作成します、Hierarchy上で右クリック Create Empty で GameObjectを生成、GameLifetimeScope.cs をアタッチします。

このまま実行しても何も起きないので GameLifetimeScope に手を加えます

using VContainer;
using VContainer.Unity;

public class GameLifetimeScope : LifetimeScope
{

    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<HelloWorldService>(Lifetime.Scoped);
        builder.RegisterEntryPoint<GamePresenter>(Lifetime.Singleton);
    }

}

利用される側のHelloWorldServiceクラスをbuilderに登録、その次に利用する側のGamePresenterをbuilderに登録します。

そして実行
コンソールが以下の様になれば正常に動作しています、Hierarchy上にはMainCamera、DirectionalLight、GameLifetimeScopeオブジェクトの3つだけでありこのログを読んだオブジェクトがシーン上に配置されていないことがわかります。

次にGameObjectから利用する場合です。
GameLifetimeScopeに以下のように手を加えます。

using UnityEngine;
using VContainer;
using VContainer.Unity;

public class GameLifetimeScope : LifetimeScope
{

    [SerializeField] TestObject testObject;


    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<HelloWorldService>(Lifetime.Scoped);
        builder.RegisterEntryPoint<GamePresenter>(Lifetime.Singleton);

        // TODO : GameObjectとの紐付け( これ以外の方法があるかはまだわからない ).
        builder.RegisterComponent(testObject);
    }

}

次にシーン上にTestObjectを配置します。
この時GameLifetimeScopeのInspectorからTestObjectをセットします。

これで実行

以下のようにコンソールが表示されれば成功です、スペースキーを押下したときに

TestObject : HelloWorld

が表示されてるのが確認できるはずです。

以上でとりあえずVContainerを導入及び簡単なサンプルの作成までの手順です

ここに一応サンプルプロジェクトを配置しています~~見る必要はないと思いますが~~

より詳細の情報やZenjectのAPIとの対応表を確認したい人は開発者のGitHubページにて確認できます

MagicLeapToolKitを利用したハンドジェスチャの検出方法

松本隆介 — Fri, 21 Aug 2020 21:08:09 +0000

以前の記事で紹介したジェスチャの取得方法はMagicLeapUnityPackageのコアシステムを利用したジェスチャの取得方法

それとは別にMagicLeapToolKitを利用したハンドジェスチャの取得方法を紹介します( かなりお手軽なのでおすすめです )

環境

LuminOS : 0.98.11
LuminSDK : 0.24.1
MagicLeapUnityPackage : 0.24.2
Unity : 2019.3.7.f1
MagicLeapToolKit : 特にバージョンが設定されていないのでこちらから最新版をDL

出来上がり

以下のようにジェスチャを取得できる機能を作成します

技術記事投稿用動画
MagicLeapのハンドジェスチャを取得するだけ
ログの表示はRuntimeConsole pic.twitter.com/RJDyHbkOyZ
— 松本隆介 (@matsumotokaka11) August 21, 2020

シーンの作成 ( 下準備 )

こちらの記事で作成したCameraRigまたは自前で作成したCameraをシーンに配置しておいてください
こちらは最低限の準備でよいと思います

次にシーンにGameObjectを作成( とりあえずHandInputとします )を作成し、MagicLeap-Tools > Code > Input > Hands ディレクトリにあるHandInputをアタッチします

次に受け取ったジェスチャイベントをログに出力したいので MagicLeap-Tools > Examples > RuntimeConsole > Scenes にあるRuntimeConsoleシーンをHierarchy上にドラッグ&ドロップし、その中からRuntimeConsoleオブジェクトを自分のテスト用シーンに移動します

これで下準備が完了しました。

スクリプトの作成

ここからがメインになります、といってもやることは簡単でHandInputにジェスチャを取得するためのイベントを登録するだけです

using MagicLeapTools;
using UnityEngine;
using UnityEngine.XR.MagicLeap;


/// <summary>
/// MLTKの手のジェスチャ取得.
/// </summary>
public class Sample : MonoBehaviour
{

    void Start()
    {
        HandInput.OnReady += () =>
        {
            HandInput.Right.Gesture.OnKeyPoseChanged += OnHandGesturePoseChanged;
            HandInput.Left.Gesture.OnKeyPoseChanged += OnHandGesturePoseChanged;
        };
    }


    private void OnHandGesturePoseChanged(
        ManagedHand hand,
        MLHandTracking.HandKeyPose pose)
    {
        // 左右の判定はこんな感じ.
        string lr = hand.Hand.Type == MLHandTracking.HandType.Left ? "left" : "right";
        Debug.Log($"{pose} {lr}");

        // 取得されたジェスチャ.
        switch (pose)
        {
            case MLHandTracking.HandKeyPose.C: break;
            case MLHandTracking.HandKeyPose.Finger: break;
            case MLHandTracking.HandKeyPose.Fist: break;
            case MLHandTracking.HandKeyPose.L: break;
            case MLHandTracking.HandKeyPose.Ok: break;
            case MLHandTracking.HandKeyPose.Pinch: break;
            case MLHandTracking.HandKeyPose.Thumb: break;
            case MLHandTracking.HandKeyPose.NoHand: break;
            case MLHandTracking.HandKeyPose.NoPose: break;
            case MLHandTracking.HandKeyPose.OpenHand: break;
        }
    }


}

↑のスクリプトで問題なくジェスチャを取得することが出来ると思います

このスクリプトを先ほど作成したHandInputにアタッチすれば稼働します

スクリプトの解説

まずStart()でHandInput.OnReadyのイベント発火時にHandInput.Right, Left双方のOnKeyPoseChangedイベントへのリスナーの登録をします
リスナーは ManagedHand型とMLHandTracking.HandKeyPose型を引数に持つメソッドです

あとがき

UniRx等を利用して複数のジェスチャを組み合わせての一連のコマンドなどを作ってみるとジェスチャの幅が広がるかも

MagicLeapのジェスチャで何かするを作ってみた
動画は右手Fist -> (1秒以内に)右手OpenHandで弾を飛ばす動作、途中二回はわざと1秒よりも長くインターバルを作りイベントが発火されないことの確認
これでジェスチャの幅が広がった pic.twitter.com/Ha3Vo9IXMd
— 松本隆介 (@matsumotokaka11) August 21, 2020

MagicLeapToolKitを利用したハンドトラッキングの実装

松本隆介 — Sun, 16 Aug 2020 17:09:52 +0000

この記事でやること

MagicLeapToolKitを利用したハンドトラッキングの実装
トラッキングした手の視覚化

今回の記事では入力イベントの取り方とかは紹介しません( 単純にまだそこまで触ってないだけ )
表示するだけだったら一瞬で終わるのでよくあるCameraRig的なプレハブ構成を作成する手順をメモってます

開発環境

OS : Windows10
Unity : 2019.3.7f1
LuminSDK : 0.24.1
MagicLeapUnityPackage : 0.24.1
MagicLeapToolKit : こちらから入手

MagicLeapToolKitはリンク先のGitHubリポジトリ内、packageフォルダの中に最新のUnity Packageが含まれているのでそこからDLしてください
まだReleaseでは特に出してないっぽい? でもpackageフォルダの更新は最近なので内部的には更新はされてるはず

出来上がるもの

MagicLeapToolKitを使ってハンドトラッキング実装してみた、表示するだけなら一瞬で終わるので良き pic.twitter.com/AG028F33Xk
— 松本隆介 (@matsumotokaka11 ) August 5, 2020

下準備

Edit > ProjectSettigs > MagicLeap にてGestureConfigと
LowLatencyLightwearにチェックを入れる

私の環境ではLowLatencyLightearには自動でチェックが入っており編集はできませんでした

シーンの構築

ここで作成したCameraRigオブジェクトを流用します、今回は自前で作成したハンドトラッキングを利用しないのでGameObjectを非アクティブにしておきます

完成予定図

MagicLeap-Tools > Examples > HandInput > Scene からHandInputシーンをHierarchyにドラッグ&ドロップし、[VISUALIZERS]オブジェクトと[INPUT]オブジェクトを複製し、自分のシーンのCameraRigオブジェクトの子オブジェクトにします

上に挙げた動画の状態にするだけであればここまでで大丈夫です、一応整理したほうが今後いろいろ改造しやすいと思うのでここから少しオブジェクトの構成をいじります

ちょこっと改造

HandInputの再構築
[INPUT]オブジェクトの中にあるHandInputオブジェクトを一つ上の階層に持っていき不要となった[INPUT]オブジェクトを削除します

↓

左右の手の描画オブジェクトを再構築
[VISUALIZERS]オブジェクトの中にあるLeft Rightオブジェクトを取り出し、HandInputオブジェクトの子オブジェクトとして配置、お好みでLeftHand,RightHandに名称を変更します

↓

このままだと各関節のKeyPointの描画オブジェクトが左右の手のGameObjectと離れていて直感的ではないのでKeyPointVisualizersオブジェクトの中からLeft~ & Right~オブジェクトをそれぞれ対応するところに配置しなおします

不要になった[VISUALIZERS]オブジェクトを削除します、今回はHandMeshは利用しないのでHandMeshごと削除します

後はお好みでLeftHand, RightHandオブジェクトにあるAxisVisualizerの長さを設定したりBoneの色を設定したりすればMagicLeapToolKitのハンドトラッキングの実装は完了します

補足
今回[VISUALIZERS]オブジェクトから引っ張ってきた各Left~, Right~オブジェクトのプレハブは MagicLeap-Tools > Prefabs > Input 内のKeyPointVisualizerプレハブを利用しています

Inspectorで描画するKeyPointの設定をカスタムすればいろいろいい感じにできそうですね

MagicLeapでTextMeshProのSpriteAssetが片目が描画されないときに確認したいこと

松本隆介 — Sun, 16 Aug 2020 16:51:04 +0000

とりあえず対症療法だけどメモ

ProjectSettings > XR Plug-in Management > MagicLeapSettings にあるForceMultipassにチェックを入れることでとりあえず描画できる

ただSinglepassStereoRendeeringのほうがパフォーマンス的にはよいのでできればTextMeshProで利用しているマテリアルをSinglepassに対応したものに差し替えたほうが良いかも

MagicLeapアプリのThe Labからのアンインストール方法

松本隆介 — Wed, 05 Aug 2020 05:24:16 +0000

The LabでDeviceBridgeを行いMagicLeapと接続する
Appタグを開くとアプリケーション一覧が確認できるのでその中から目的のアプリを削除する

アプリの終了処理とか入れ忘れた時とかアプリが重くなりすぎて動かせないとかって時に便利よね

MagicLeapのハンドトラッキング実装

松本隆介 — Thu, 30 Jul 2020 16:08:09 +0000

MagicLeapのハンドトラッキング実装の備忘録

基本的にはここの通りに進めていけば問題ない

前提となるもの

MagicLeapのmpkをビルドできる段階までのセッティングが完了している
The LabでのZeroIterationが可能になっている

開発環境
Windows10
Unity 2019.3.7f1
MagicLeapUnityPackage 0.24.1

出来上がり

こんな感じに各関節
手首、親指 ~ 小指までの座標の取得
ジェスチャの取得( サンプルの中では利用していない )

MagicLeapのハンドトラッキング実装してみた pic.twitter.com/ZSYl1BVXay
— 松本隆介 (@matsumotokaka11) July 30, 2020

実装方法

下準備

シーンに配置するGameObject
大体のVRデバイスとかで主流な構成の配置にしてます

CameraRig
ただのルートオブジェクトとして利用しています

Head
MagicLeapパッケージ内 Core > Assets > Prefabs > MainCamera
のプレハブをCameraRigの子オブジェクトにしてHeadと名称を変えたものです、この中にDirectionalLightを子オブジェクトとして配置していますが配置するか否かはお好みで

Controller
MagicLeapパッケージ内 Examples > Assets > Prefabs > Controller
のプレハブをCameraRigの子オブジェクトとして配置しています
こちらの記事で紹介したコントローラの入力でホームボタンでアプリを閉じるために利用してます

LHand, RHand
今回のメイン
CameraRigの子オブジェクトとしてGameObjectを作成( Emptyとして )
Thumb( 親指 ), Index( 人差し指 ), Middle( 中指 ), Ring( 薬指 ), Pinky( 小指 )をそれぞれEmptyのGameObjectで作成し、
各指の子オブジェクトThumb, Index, Middleは3個、Ring, Pinkyは2個、SphereObjectを生成、スケールは0.01くらいに設定

スクリプト

このスクリプトはMagicLeap公式サンプルのものに手を加えたものです
以下のスクリプトをLHand, RHandにアタッチ

using UnityEngine;
using UnityEngine.XR.MagicLeap;

/// <summary>
/// ハンドトラッキング.
/// </summary>
public class HandController : MonoBehaviour
{

    [System.Serializable]
    public class HandJointData
    {
        [SerializeField] GameObject wrist;
        [SerializeField] GameObject[] thumb;
        [SerializeField] GameObject[] index;
        [SerializeField] GameObject[] middle;
        [SerializeField] GameObject[] ring;
        [SerializeField] GameObject[] pinky;
        [SerializeField] Material handMaterial;
        [SerializeField] Color color;

        public Vector3 Wrist { get; private set; }
        public Vector3[] Thumb { get; private set; }
        public Vector3[] Index { get; private set; }
        public Vector3[] Middle { get; private set; }
        public Vector3[] Ring { get; private set; }
        public Vector3[] Pinky { get; private set; }
        MLHandTracking.Hand hand;
        LineRenderer[] lines;

        public void Initialize(
            MLHandTracking.Hand _hand)
        {
            hand = _hand;
            Wrist = Vector3.zero;

            // 各関節 + 手首の分, 配列をとる.
            Thumb = new Vector3[thumb.Length + 1];
            Index = new Vector3[index.Length + 1];
            Middle = new Vector3[middle.Length + 1];
            Ring = new Vector3[ring.Length + 1];
            Pinky = new Vector3[pinky.Length + 1];

            lines = new LineRenderer[5];
            lines[0] = thumb[0].transform.parent.gameObject.AddComponent<LineRenderer>();
            lines[0].positionCount = 4;

            lines[1] = index[0].transform.parent.gameObject.AddComponent<LineRenderer>();
            lines[1].positionCount = 4;

            lines[2] = middle[0].transform.parent.gameObject.AddComponent<LineRenderer>();
            lines[2].positionCount = 4;

            lines[3] = ring[0].transform.parent.gameObject.AddComponent<LineRenderer>();
            lines[3].positionCount = 3;

            lines[4] = pinky[0].transform.parent.gameObject.AddComponent<LineRenderer>();
            lines[4].positionCount = 3;

            // LineRendererの初期セッティング.
            foreach (var line in lines)
            {
                line.material = handMaterial;
                line.startColor = color;
                line.endColor = color;
                line.startWidth = 0.01f;
                line.endWidth = 0.01f;
            }
        }


        public void UpdatePositions()
        {
            if (hand == null) return;

            Thumb[0] = hand.Wrist.KeyPoints[0].Position;
            Thumb[1] = hand.Thumb.KeyPoints[0].Position;
            Thumb[2] = hand.Thumb.KeyPoints[1].Position;
            Thumb[3] = hand.Thumb.KeyPoints[2].Position;
            for (var i = 1; i < Thumb.Length; ++i)
            {
                thumb[i - 1].transform.position = Thumb[i];
            }
            lines[0].SetPositions(Thumb);

            Index[0] = hand.Wrist.KeyPoints[0].Position;
            Index[1] = hand.Index.KeyPoints[0].Position;
            Index[2] = hand.Index.KeyPoints[1].Position;
            Index[3] = hand.Index.KeyPoints[2].Position;
            for (var i = 1; i < Index.Length; ++i)
            {
                index[i - 1].transform.position = Index[i];
            }
            lines[1].SetPositions(Index);

            Middle[0] = hand.Wrist.KeyPoints[0].Position;
            Middle[1] = hand.Middle.KeyPoints[0].Position;
            Middle[2] = hand.Middle.KeyPoints[1].Position;
            Middle[3] = hand.Middle.KeyPoints[2].Position;
            for (var i = 1; i < Middle.Length; ++i)
            {
                middle[i - 1].transform.position = Middle[i];
            }
            lines[2].SetPositions(Middle);

            Ring[0] = hand.Wrist.KeyPoints[0].Position;
            Ring[1] = hand.Ring.KeyPoints[0].Position;
            Ring[2] = hand.Ring.KeyPoints[1].Position;
            for (var i = 1; i < Ring.Length; ++i)
            {
                ring[i - 1].transform.position = Ring[i];
            }
            lines[3].SetPositions(Ring);

            Pinky[0] = hand.Wrist.KeyPoints[0].Position;
            Pinky[1] = hand.Pinky.KeyPoints[0].Position;
            Pinky[2] = hand.Pinky.KeyPoints[1].Position;
            for (var i = 1; i < Pinky.Length; ++i)
            {
                pinky[i - 1].transform.position = Pinky[i];
            }
            lines[4].SetPositions(Pinky);

        }
    }


    // ジェスチャ.
    public enum HandPoses
    {
        Ok,
        Finger,
        Thumb,
        OpenHand,
        Fist,
        NoPose,
        NoHand,
    }

    public enum HandId
    {
        RightHand,
        LeftHand
    }


    [SerializeField] HandPoses handPose = HandPoses.NoPose;
    [SerializeField] HandJointData handData;
    [SerializeField] HandId handId;
    MLHandTracking.HandKeyPose[] gestures;
    MLHandTracking.Hand hand;


    void Start()
    {
        // HandTrackingを開始する.
        MLHandTracking.Start();

        hand = handId == HandId.LeftHand ? MLHandTracking.Left : MLHandTracking.Right;
        handData.Initialize(hand);

        gestures = new MLHandTracking.HandKeyPose[6];

        // 各ジェスチャを登録.
        gestures[0] = MLHandTracking.HandKeyPose.Ok;
        gestures[1] = MLHandTracking.HandKeyPose.Finger;
        gestures[2] = MLHandTracking.HandKeyPose.OpenHand;
        gestures[3] = MLHandTracking.HandKeyPose.Fist;
        gestures[4] = MLHandTracking.HandKeyPose.Thumb;
        gestures[5] = MLHandTracking.HandKeyPose.NoHand;

        MLHandTracking.KeyPoseManager.EnableKeyPoses(gestures, true, false);

    }


    void OnDestroy()
    {
        MLHandTracking.Stop();
    }


    void Update()
    {
        handData.UpdatePositions();

        if (GetGesture(hand, MLHandTracking.HandKeyPose.Ok))
        {
            handPose = HandPoses.Ok;
        }
        else if (GetGesture(hand, MLHandTracking.HandKeyPose.Finger))
        {
            handPose = HandPoses.Finger;
        }
        else if (GetGesture(hand, MLHandTracking.HandKeyPose.OpenHand))
        {
            handPose = HandPoses.OpenHand;
        }
        else if (GetGesture(hand, MLHandTracking.HandKeyPose.Fist))
        {
            handPose = HandPoses.Fist;
        }
        else if (GetGesture(hand, MLHandTracking.HandKeyPose.Thumb))
        {
            handPose = HandPoses.Thumb;
        }
        else
        {
            handPose = HandPoses.NoPose;
        }
    }


    /// <summary>
    /// ジェスチャの取得.
    /// </summary>
    /// <param name="hand"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    private bool GetGesture(
        MLHandTracking.Hand hand, 
        MLHandTracking.HandKeyPose type)
    {
        if (hand == null) return false;

        return 0.9f < hand.HandKeyPoseConfidence && hand.KeyPose == type;
    }

}

アタッチしたら以下の画像のように各関節のオブジェクトをセット、配列の添え字が若い方が根元に来るように設定

各パラメータの説明
HandPose : ジェスチャのポーズ名( 今回はInspectorに表示しているだけです )
HandData : 各関節のオブジェクトを保持するクラス、HandCenterは利用していません( うまくトラッキングできなかったので外しました )
HandMaterial : 各関節オブジェクトの球をつなぐ線の描画用マテリアルです、今回はMagicLeapパッケージ内のUIBeamを利用しました
Color : 各関節オブジェクトの球をつなぐ線の色です、今回は左は赤、右は緑で設定しています
HandId : 手の左右を決定する識別子

Unity の設定

この状態でTheLabでMagicLeapと接続してPlayModeに入るとハンドトラッキングされたオブジェクトの様子が確認できると思います
ただしmpkファイルとして出力する際は以下の設定を行わないと実機ではエラーが出てハンドトラッキング及びジェスチャの取得はできません
~~公式のチュートリアル通りにやれば設定の仕方まで説明されてたけど必要なメソッドとか確認したらすぐ実行したくなっちゃうのよね~~

Edit > ProjectSettigs > MagicLeap > ManifestSettings の項目を開き
GestureConfig, GestureSubscribeにチェックを入れる ( 公式チュートリアルだと明示的にLowLatencyLightwearにもチェックを入れるように説明されているが現バージョンでは自動で入ってる? )

これでmpkを出力して実機でテストするとハンドトラッキングが実装できているはずです

あとがき

これはTheLabからDLしてきたMagicLeapUnityPackageでのサンプルです、MagicLeapToolKitでのハンドトラッキングはまだ触ったことがないので後日記事にできればと思います

MagicLeapコントローラのイベント取得方法

松本隆介 — Wed, 01 Jul 2020 17:20:48 +0000

公式のチュートリアルの動画だと若干コードが古かったりしたのでメモ

詳細な動作については後日追記予定

以下のボタン操作のバインディングのメモ

バンパーボタン
ホームボタン
タッチパッド
トリガー

using UnityEngine;
using UnityEngine.XR.MagicLeap;


/// <summary>
/// MagicLeapコントローラ.
/// </summary>
public class MlController : MonoBehaviour, IController
{

    [SerializeField] MLInput.Controller controller;

    void Start()
    {
        // コントローラの入力を有効にし,対応するイベントハンドラを登録する.
        MLInput.Start();
        MLInput.OnControllerButtonDown += OnButtonDown;
        MLInput.OnControllerButtonUp += OnButtonUp;

        MLInput.OnTriggerDown += OnTriggerDown;
        MLInput.OnTriggerUp += OnTriggerUp;

        MLInput.OnControllerTouchpadGestureStart += OnTouchPadGestureStart;
        MLInput.OnControllerTouchpadGestureContinue += OnTouchPadGestureContinue;
        MLInput.OnControllerTouchpadGestureEnd += OnTouchPadGestureEnd;
    }


    void OnDestroy()
    {
        // コントローラの入力を無効にし,登録していたイベントハンドラを削除する.
        MLInput.Stop();
        MLInput.OnControllerButtonDown -= OnButtonDown;
        MLInput.OnControllerButtonUp -= OnButtonUp;

        MLInput.OnTriggerDown -= OnTriggerDown;
        MLInput.OnTriggerUp -= OnTriggerUp;

        MLInput.OnControllerTouchpadGestureStart -= OnTouchPadGestureStart;
        MLInput.OnControllerTouchpadGestureContinue -= OnTouchPadGestureContinue;
        MLInput.OnControllerTouchpadGestureEnd -= OnTouchPadGestureEnd;
    }


    /// <summary>
    /// ボタン押下時の処理.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="button"></param>
    void OnButtonDown(
        byte controllerId,
        MLInput.Controller.Button button)
    {
        switch (button)
        {
            case MLInput.Controller.Button.Bumper:
                break;

            case MLInput.Controller.Button.HomeTap:
                Application.Quit();
                break;
        }
    }


    /// <summary>
    /// ボタン押上時の処理.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="button"></param>
    void OnButtonUp(
        byte controllerId,
        MLInput.Controller.Button button)
    {
        switch (button)
        {
            case MLInput.Controller.Button.Bumper:
                break;

            case MLInput.Controller.Button.HomeTap:
                break;
        }
    }


    /// <summary>
    /// トリガーの押下処理.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="value"></param>
    void OnTriggerDown(
        byte controllerId,
        float value)
    {
    }


    /// <summary>
    /// トリガーの押上処理.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="value"></param>
    void OnTriggerUp(
        byte controllerId,
        float value)
    {
    }


    /// <summary>
    /// タッチパッドのジェスチャー始点.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="gesture"></param>
    void OnTouchPadGestureStart(
        byte controllerId,
        MLInput.Controller.TouchpadGesture gesture)
    {
    }

    /// <summary>
    /// タッチパッドのジェスチャー操作中.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="gesture"></param>
    void OnTouchPadGestureContinue(
        byte controllerId,
        MLInput.Controller.TouchpadGesture gesture)
    {
    }


    /// <summary>
    /// タッチパッドのジェスチャ終点.
    /// </summary>
    /// <param name="controllerId"></param>
    /// <param name="gesture"></param>
    void OnTouchPadGestureEnd(
        byte controllerId,
        MLInput.Controller.TouchpadGesture gesture)
    {
    }

}

取得結果

MagicLeapのインプット回り取れるようにした( ついでにそれっぽいデバッグウィンドウも作ってみた pic.twitter.com/KiFPQMpIzk
— 松本隆介 (@matsumotokaka11) July 5, 2020

MagicLeap開発備忘録

松本隆介 — Sun, 28 Jun 2020 18:28:10 +0000

個人的な備忘録、場合によっては情報が古い可能性もあり