Architectural Ergonomics

Unity

IVE ＝ immersive Virtual Environment / 没入型仮想環境

Meta Quest ProをMeta Horizon Linkで接続したUnity Editor上でのアイトラッキング取得

Meta Quest ProをMeta Horizon LinkでPCへ接続し、Unity EditorのPlay Mode上でアイトラッキングを行う環境を構築した。

本ページでは、Unity OpenXRの一般的なEye Gaze取得方法では視線情報を取得できなかった事例と、OpenXR Extension XR_FB_eye_tracking_social を利用して取得に成功した方法についてまとめる。

検証環境

HMD：Meta Quest Pro
接続：Meta Horizon Link
Meta Horizon Link：208系
Unity：6000.4.7f1
XR：Unity OpenXR
実行環境：Windows
実行方法：Unity Editor Play Mode
OpenXR Runtime：Meta Quest Link側OpenXR Runtime

本検証では、Quest向けAndroidアプリとしてビルドするのではなく、Meta Horizon Linkを介してQuest ProをPCへ接続し、Unity Editor上でVR表示とアイトラッキングを同時に行うことを対象とした。

Meta XR Feature有効時にEditor Playできない

Meta Quest Proを使用するため、当初はMetaが提供するMeta XR SDKを導入し、OpenXR設定内のMeta XR Featureを有効化した。

しかし、本検証環境ではこの状態でUnity EditorのPlay Modeを開始すると、Meta Horizon Linkとの接続自体は成立しているものの、HMD側が待機画面からUnityのVR画面へ遷移せず、Editor Playを行うことができなかった。

検証の結果、Standalone環境では以下の構成とすることで、Meta Horizon Link経由のEditor Playが可能となった。

OpenXR ON

Initialize XR on Startup ON

Oculus Touch Controller Profile ON

Meta XR Feature OFF

Meta XR Foveation OFF

このため、本環境ではMeta XR Featureを使用せず、Unity OpenXRを基本とした構成で開発を進めた。

また、Meta Project Setup Toolでは推奨設定への変更が提示される場合があるが、設定を一括で適用すると、動作確認済みのOpenXR設定が変更される可能性がある。そのため、本環境では各項目を確認しながら個別に設定した。

Unity OpenXR標準のEye Gazeでは取得できなかった

はじめに、Unity OpenXRで一般的に用いられる Eye Gaze Interaction Profile を有効化し、Unity Input Systemの<EyeGaze>デバイスから視線Poseを取得する方法を試した。

Unity側ではEye Gazeデバイス自体は認識され、OpenXR Runtime上でも XR_EXT_eye_gaze_interaction が利用可能であることを確認できた。しかし、実際に取得される値は初期値のままであり、HMD内で視線を移動させても値は変化せず、有効な視線Poseを取得することができなかった。

このことから、今回のUnity・Meta Horizon Link・OpenXR Runtimeの組み合わせでは、Unity標準の XR_EXT_eye_gaze_interaction を利用する経路からQuest Proの視線情報を取得できないと判断した。

なお、これはQuest Proのアイトラッキング機能そのものが利用できないことを意味するものではない。同じHMD・PC・Meta Horizon Link環境において別の実行環境では視線取得が可能であったため、Unity標準のEye Gaze取得経路に原因があると考えた。

OpenXR RuntimeのExtensionを確認

次に、Unityから利用可能なOpenXR Extensionを確認した。その結果、Eye Trackingに関連するExtensionとして以下が確認できた。

XR_EXT_eye_gaze_interaction
XR_FB_eye_tracking_social
XR_HTC_eye_tracker

XR_EXT_eye_gaze_interaction では正常に取得できなかった一方で、Meta向けExtensionである XR_FB_eye_tracking_social がRuntimeから公開されていた。

そこで、Unity標準のEye Gaze Interaction Profileを経由せず、XR_FB_eye_tracking_social を直接利用する方法を試した。

XR_FB_eye_tracking_social を利用した視線取得

Unity OpenXRのカスタムFeatureを作成し、XR_FB_eye_tracking_social を有効化した。

OpenXRの関数ポインタを取得し、主に以下のAPIを利用した。

xrCreateEyeTrackerFB
xrDestroyEyeTrackerFB

xrGetEyeGazesFB

Eye Trackerの生成は正常終了し、xrGetEyeGazesFB を呼び出すことで左右眼それぞれの視線Poseを取得できた。

取得時には左右眼とも有効状態となり、Confidenceも約0.998を示した。

LeftValid = True
RightValid = True
LeftConfidence ≈ 0.998

RightConfidence ≈ 0.998

HMD内で視線を移動させると、取得される眼球回転も連続的に変化し、Meta Horizon Link経由でもQuest Proのアイトラッキング情報がUnity Editorまで届いていることを確認した。

Unity座標系への変換

xrGetEyeGazesFB から取得したPoseは、そのままではUnityの座標系と一致しないため変換を行った。

本環境では、位置およびQuaternionについて以下の変換を用いた。

Position (x, y, z)　→　(x, y, -z)
Rotation (x, y, z, w)　→　(-x, -y, z, w)

正面・左・右・上・下に配置したターゲットを注視するテストを行い、それぞれの方向に対して取得した視線ベクトルが正しく変化することを確認した。

注意点

今回の結果は、Meta Quest Pro、Meta Horizon Link、Unity 6000.4.7f1、Unity OpenXRを組み合わせた検証環境における結果である。

そのため、

「UnityではQuest ProのEye Trackingを取得できない」

という意味ではなく、

「今回の環境ではUnity OpenXR標準の XR_EXT_eye_gaze_interaction 経路では正常に取得できず、XR_FB_eye_tracking_social を直接利用することで取得できた」

という結果である。

Meta Horizon Link、OpenXR Runtime、Unity、OpenXR Plugin等の更新によって挙動が変化する可能性がある。また、XR_FB_eye_tracking_social はMeta向けExtensionであるため、他社製HMDへの移植性についても注意が必要である。

FBEyeTrackingSocialFeature.cs

using System;using System.Runtime.InteropServices;using UnityEngine;using UnityEngine.XR.OpenXR;using UnityEngine.XR.OpenXR.Features;
#if UNITY_EDITORusing UnityEditor;using UnityEditor.XR.OpenXR.Features;
[OpenXRFeature(    UiName = "FB Eye Tracking Social",    BuildTargetGroups = new[] { BuildTargetGroup.Standalone },    Company = "Research",    Desc = "Quest Pro eye tracking via XR_FB_eye_tracking_social",    OpenxrExtensionStrings =        "XR_FB_eye_tracking_social " +        "XR_KHR_win32_convert_performance_counter_time",    Version = "1.0.0",    FeatureId = FeatureId)]#endifpublic class FBEyeTrackingSocialFeature : OpenXRFeature{    public const string FeatureId = "research.openxr.fbeyetracking";
    const int XR_SUCCESS = 0;    const int XR_TYPE_EYE_TRACKER_CREATE_INFO_FB = 1000202001;    const int XR_TYPE_EYE_GAZES_INFO_FB = 1000202002;    const int XR_TYPE_EYE_GAZES_FB = 1000202003;
    ulong instance, eyeTracker;    IntPtr getProcAddrPtr;
    XrGetInstanceProcAddrDelegate getProcAddr;    XrCreateEyeTrackerFBDelegate createEyeTracker;    XrDestroyEyeTrackerFBDelegate destroyEyeTracker;    XrGetEyeGazesFBDelegate getEyeGazes;    XrConvertWin32PerformanceCounterToTimeKHRDelegate convertTime;
    [StructLayout(LayoutKind.Sequential)]    struct XrEyeTrackerCreateInfoFB    {        public int type;        public IntPtr next;    }
    [StructLayout(LayoutKind.Sequential)]    public struct XrVector3f    {        public float x, y, z;    }
    [StructLayout(LayoutKind.Sequential)]    public struct XrQuaternionf    {        public float x, y, z, w;    }
    [StructLayout(LayoutKind.Sequential)]    public struct XrPosef    {        public XrQuaternionf orientation;        public XrVector3f position;    }
    [StructLayout(LayoutKind.Sequential)]    public struct XrEyeGazeFB    {        public uint isValid;        public XrPosef gazePose;        public float gazeConfidence;    }
    [StructLayout(LayoutKind.Sequential)]    struct XrEyeGazesInfoFB    {        public int type;        public IntPtr next;        public ulong baseSpace;        public long time;    }
    [StructLayout(LayoutKind.Sequential)]    struct XrEyeGazesFB    {        public int type;        public IntPtr next;        public XrEyeGazeFB left;        public XrEyeGazeFB right;        public long time;    }
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]    delegate int XrGetInstanceProcAddrDelegate(        ulong instance, string name, out IntPtr function);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]    delegate int XrCreateEyeTrackerFBDelegate(        ulong session, ref XrEyeTrackerCreateInfoFB info, out ulong tracker);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]    delegate int XrDestroyEyeTrackerFBDelegate(ulong tracker);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]    delegate int XrGetEyeGazesFBDelegate(        ulong tracker, ref XrEyeGazesInfoFB info, ref XrEyeGazesFB gazes);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]    delegate int XrConvertWin32PerformanceCounterToTimeKHRDelegate(        ulong instance, ref long counter, out long time);
    [DllImport("Kernel32.dll")]    static extern bool QueryPerformanceCounter(out long counter);
    protected override IntPtr HookGetInstanceProcAddr(IntPtr func)    {        getProcAddrPtr = func;        return func;    }
    protected override bool OnInstanceCreate(ulong xrInstance)    {        instance = xrInstance;
        if (!OpenXRRuntime.IsExtensionEnabled("XR_FB_eye_tracking_social") ||            !OpenXRRuntime.IsExtensionEnabled(                "XR_KHR_win32_convert_performance_counter_time"))            return false;
        getProcAddr =            Marshal.GetDelegateForFunctionPointer<XrGetInstanceProcAddrDelegate>(                getProcAddrPtr);
        return Load("xrCreateEyeTrackerFB", out createEyeTracker) &&               Load("xrDestroyEyeTrackerFB", out destroyEyeTracker) &&               Load("xrGetEyeGazesFB", out getEyeGazes) &&               Load("xrConvertWin32PerformanceCounterToTimeKHR", out convertTime) &&               base.OnInstanceCreate(xrInstance);    }
    protected override void OnSessionCreate(ulong session)    {        var info = new XrEyeTrackerCreateInfoFB        {            type = XR_TYPE_EYE_TRACKER_CREATE_INFO_FB,            next = IntPtr.Zero        };
        int result = createEyeTracker(session, ref info, out eyeTracker);        Debug.Log($"xrCreateEyeTrackerFB result={result}, tracker={eyeTracker}");    }
    protected override void OnSessionDestroy(ulong session)    {        if (eyeTracker != 0)        {            destroyEyeTracker?.Invoke(eyeTracker);            eyeTracker = 0;        }        base.OnSessionDestroy(session);    }
    public bool TryGetEyeGazes(        out XrEyeGazeFB left,        out XrEyeGazeFB right,        out long gazeTime)    {        left = default;        right = default;        gazeTime = 0;
        if (eyeTracker == 0 || getEyeGazes == null || convertTime == null)            return false;
        ulong appSpace = GetCurrentAppSpace();        if (appSpace == 0 || !QueryPerformanceCounter(out long counter))            return false;
        if (convertTime(instance, ref counter, out long xrTime) != XR_SUCCESS)            return false;
        var info = new XrEyeGazesInfoFB        {            type = XR_TYPE_EYE_GAZES_INFO_FB,            next = IntPtr.Zero,            baseSpace = appSpace,            time = xrTime        };
        var gazes = new XrEyeGazesFB        {            type = XR_TYPE_EYE_GAZES_FB,            next = IntPtr.Zero        };
        if (getEyeGazes(eyeTracker, ref info, ref gazes) != XR_SUCCESS)            return false;
        left = gazes.left;        right = gazes.right;        gazeTime = gazes.time;        return true;    }
    bool Load<T>(string name, out T function) where T : Delegate    {        function = null;
        if (getProcAddr(instance, name, out IntPtr ptr) != XR_SUCCESS ||            ptr == IntPtr.Zero)            return false;
        function = Marshal.GetDelegateForFunctionPointer<T>(ptr);        return true;    }}

FBEyeGazeProvider.cs

using UnityEngine;using UnityEngine.XR.OpenXR;
public class FBEyeGazeProvider : MonoBehaviour{    [SerializeField] Transform trackingOrigin;    [Range(0f, 1f)]    [SerializeField] float minimumConfidence = 0f;
    public bool IsValid { get; private set; }    public Vector3 Origin { get; private set; }    public Vector3 Direction { get; private set; }    public float Confidence { get; private set; }
    FBEyeTrackingSocialFeature feature;
    void Start()    {        feature = OpenXRSettings.Instance?            .GetFeature<FBEyeTrackingSocialFeature>();    }
    void Update()    {        IsValid = false;        if (feature == null) return;
        if (!feature.TryGetEyeGazes(out var left, out var right, out _))            return;
        bool lValid =            left.isValid != 0 && left.gazeConfidence >= minimumConfidence;        bool rValid =            right.isValid != 0 && right.gazeConfidence >= minimumConfidence;
        if (!lValid && !rValid) return;
        if (lValid && rValid)        {            Convert(left, out Vector3 lp, out Vector3 ld);            Convert(right, out Vector3 rp, out Vector3 rd);
            Origin = (lp + rp) * 0.5f;            Direction = (ld + rd).normalized;            Confidence =                (left.gazeConfidence + right.gazeConfidence) * 0.5f;        }        else        {            var gaze = lValid ? left : right;            Convert(gaze, out Vector3 p, out Vector3 d);
            Origin = p;            Direction = d;            Confidence = gaze.gazeConfidence;        }
        IsValid = true;    }
    void Convert(        FBEyeTrackingSocialFeature.XrEyeGazeFB gaze,        out Vector3 worldPosition,        out Vector3 worldDirection)    {        Vector3 localPosition = new Vector3(            gaze.gazePose.position.x,            gaze.gazePose.position.y,            -gaze.gazePose.position.z);
        Quaternion rotation = new Quaternion(            -gaze.gazePose.orientation.x,            -gaze.gazePose.orientation.y,             gaze.gazePose.orientation.z,             gaze.gazePose.orientation.w);
        Vector3 localDirection =            (rotation * Vector3.forward).normalized;
        if (trackingOrigin != null)        {            worldPosition = trackingOrigin.TransformPoint(localPosition);            worldDirection =                trackingOrigin.TransformDirection(localDirection).normalized;        }        else        {            worldPosition = localPosition;            worldDirection = localDirection;        }    }}