version 2.4.2

Author: Sean Lu

com.htc.upm.vive.openxr/Runtime/Features/EyeTracker.meta

@@ -325,6 +325,23 @@ public enum XrStructureType
         XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004,
         XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000,
         XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001,
+        XR_TYPE_PERSISTED_ANCHOR_COLLECTION_CREATE_INFO_HTC = 1000320000,
+        XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_HTC = 1000320001,
+        XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_HTC = 1000320002,
+        XR_TYPE_PERSISTED_ANCHOR_PROPERTIES_GET_INFO_HTC = 1000320003,
+        XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB = 1000171000,
+        XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB = 1000171001,
+        XR_TYPE_EYE_TRACKER_CREATE_INFO_HTC = 1000326001,
+        XR_TYPE_EYE_GAZE_DATA_INFO_HTC = 1000326002,
+        XR_TYPE_EYE_GAZE_DATA_HTC = 1000326003,
+        XR_TYPE_SINGLE_EYE_GAZE_DATA_HTC = 1000326004,
+        XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_HTC = 1000326005,
+        XR_TYPE_EYE_PUPIL_DATA_INFO_HTC = 1000326006,
+        XR_TYPE_EYE_PUPIL_DATA_HTC = 1000326007,
+        XR_TYPE_SINGLE_EYE_PUPIL_DATA_HTC = 1000326008,
+        XR_TYPE_EYE_GEOMETRIC_DATA_INFO_HTC = 1000326009,
+        XR_TYPE_EYE_GEOMETRIC_DATA_HTC = 1000326010,
+        XR_TYPE_SINGLE_EYE_GEOMETRIC_DATA_HTC = 1000326011,
         XR_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
     }
     /// <summary>

com.htc.upm.vive.openxr/Runtime/Features/EyeTracker/ViveEyeTracker.cs

@@ -0,0 +1,143 @@
+// ===================== 2022 HTC Corporation. All Rights Reserved. ===================
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+using VIVE.OpenXR.EyeTracker;
+
+namespace VIVE.OpenXR
+{
+    public class XR_HTC_eye_tracker_defs
+    {
+        public virtual XrResult xrCreateEyeTrackerHTC(XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
+        {
+            eyeTracker = 0;
+            return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+        }
+        public virtual XrResult xrDestroyEyeTrackerHTC(XrEyeTrackerHTC eyeTracker)
+        {
+            return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+        }
+        protected XrEyeGazeDataHTC m_eyeGazes = new XrEyeGazeDataHTC(); //= new XrEyeGazeDataHTC(XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC, IntPtr.Zero, 0);
+        public virtual XrResult xrGetEyeGazeDataHTC(XrEyeTrackerHTC eyeTracker, XrEyeGazeDataInfoHTC gazeInfo, out XrEyeGazeDataHTC eyeGazes)
+        {
+            m_eyeGazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
+            m_eyeGazes.next = IntPtr.Zero;
+            m_eyeGazes.time = 0;
+            eyeGazes = m_eyeGazes;
+            return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+        }
+        public virtual bool GetEyeGazeData(out XrSingleEyeGazeDataHTC[] out_gazes)
+        {
+            m_eyeGazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
+            m_eyeGazes.next = IntPtr.Zero;
+            m_eyeGazes.time = 0;
+            out_gazes = m_eyeGazes.gaze;
+            return false;
+        }
+        protected XrEyePupilDataHTC m_pupilData = new XrEyePupilDataHTC();
+        public virtual XrResult xrGetEyePupilDataHTC(XrEyeTrackerHTC eyeTracker, XrEyePupilDataInfoHTC pupilDataInfo, out XrEyePupilDataHTC pupilData)
+        {
+            m_pupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
+            m_pupilData.next = IntPtr.Zero;
+            m_pupilData.time = 0;
+            pupilData = m_pupilData;
+            return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+        }
+        public virtual bool GetEyePupilData(out XrSingleEyePupilDataHTC[] pupilData)
+        {
+            m_pupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
+            m_pupilData.next = IntPtr.Zero;
+            m_pupilData.time = 0;
+            pupilData = m_pupilData.pupilData;
+            return false;
+        }
+        protected XrEyeGeometricDataHTC m_eyeGeometricData = new XrEyeGeometricDataHTC();
+        public virtual XrResult xrGetEyeGeometricDataHTC(XrEyeTrackerHTC eyeTracker,
+            XrEyeGeometricDataInfoHTC info,
+            out XrEyeGeometricDataHTC eyeGeometricData)
+        {
+            m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
+            m_eyeGeometricData.next = IntPtr.Zero;
+            m_eyeGeometricData.time = 0;
+            eyeGeometricData = m_eyeGeometricData;
+            return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+        }
+        public virtual bool GetEyeGeometricData(out XrSingleEyeGeometricDataHTC[] geometricData)
+        {
+            m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
+            m_eyeGeometricData.next = IntPtr.Zero;
+            m_eyeGeometricData.time = 0;
+            geometricData = m_eyeGeometricData.eyeGeometricData;
+            return false;
+        }
+    }
+    public class XR_HTC_eye_tracker
+    {
+        static XR_HTC_eye_tracker_defs m_Instance = null;
+        public static XR_HTC_eye_tracker_defs Interop
+        {
+            get
+            {
+                if (m_Instance == null)
+                {
+                    m_Instance = new XR_HTC_eye_tracker_impls();
+                }
+                return m_Instance;
+            }
+        }
+
+        /// <summary>
+        /// An application can create an <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle using CreateEyeTracker.
+        /// </summary>
+        /// <param name="createInfo">The <see cref="XrEyeTrackerCreateInfoHTC">XrEyeTrackerCreateInfoHTC</see> used to specify the eye tracker.</param>
+        /// <param name="eyeTracker">The returned XrEyeTrackerHTC handle.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public static XrResult xrCreateEyeTrackerHTC(XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
+        {
+            return Interop.xrCreateEyeTrackerHTC(createInfo,out eyeTracker);
+        }
+        /// <summary>
+        /// Releases the eye tracker and the underlying resources when the eye tracking experience is over.
+        /// </summary>
+        /// <param name="eyeTracker">An XrEyeTrackerHTC previously created by xrCreateEyeTrackerHTC.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public static XrResult xrDestroyEyeTrackerHTC(XrEyeTrackerHTC eyeTracker)
+        {
+            return Interop.xrDestroyEyeTrackerHTC(eyeTracker);
+        }
+        /// <summary>
+        /// Retrieves the <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see> data of a <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see>.
+        /// </summary>
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
+        /// <param name="gazeInfo">The information to get eye gaze.</param>
+        /// <param name="eyeGazes">Output parameter to retrieve a pointer to <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see> receiving the returned eye poses.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public static XrResult xrGetEyeGazeDataHTC(XrEyeTrackerHTC eyeTracker, XrEyeGazeDataInfoHTC gazeInfo, out XrEyeGazeDataHTC eyeGazes)
+        {
+            return Interop.xrGetEyeGazeDataHTC(eyeTracker, gazeInfo, out eyeGazes);
+        }
+        /// <summary>
+        /// Retrieves the <see cref="XrEyePupilDataHTC">XrEyePupilDataHTC</see> data of a <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see>.
+        /// </summary>
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
+        /// <param name="pupilDataInfo">The information to get pupil data.</param>
+        /// <param name="pupilData">A pointer to <see cref="XrEyePupilDataHTC">XrEyePupilDataHTC</see> returned by the runtime.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public static XrResult xrGetEyePupilDataHTC(XrEyeTrackerHTC eyeTracker, XrEyePupilDataInfoHTC pupilDataInfo, out XrEyePupilDataHTC pupilData)
+        {
+            return Interop.xrGetEyePupilDataHTC(eyeTracker, pupilDataInfo, out pupilData);
+        }
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
+        /// <param name="info">A pointer to <see cref="XrEyeGeometricDataInfoHTC">XrEyeGeometricDataInfoHTC</see> structure.</param>
+        /// <param name="eyeGeometricData">A pointer to <see cref="XrEyeGeometricDataHTC">XrEyeGeometricDataHTC</see> returned by the runtime.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public static XrResult xrGetEyeGeometricDataHTC(XrEyeTrackerHTC eyeTracker,
+            XrEyeGeometricDataInfoHTC info,
+            out XrEyeGeometricDataHTC eyeGeometricData)
+        {
+            return Interop.xrGetEyeGeometricDataHTC(eyeTracker,info, out eyeGeometricData);
+        }
+    }
+}

com.htc.upm.vive.openxr/Runtime/Features/EyeTracker/ViveEyeTracker.cs.meta

@@ -0,0 +1,132 @@
+// ===================== 2022 HTC Corporation. All Rights Reserved. ===================
+
+using UnityEngine;
+
+using UnityEngine.XR.OpenXR;
+
+using VIVE.OpenXR.EyeTracker;
+
+
+namespace VIVE.OpenXR
+{
+    public class XR_HTC_eye_tracker_impls : XR_HTC_eye_tracker_defs
+    {
+        const string LOG_TAG = "VIVE.OpenXR.XR_HTC_eye_tracker_impls";
+        void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+
+        private ViveEyeTracker feature = null;
+        private void ASSERT_FEATURE()
+        {
+            if (feature == null) { feature = OpenXRSettings.Instance.GetFeature<ViveEyeTracker>(); }
+        }
+
+        public override XrResult xrCreateEyeTrackerHTC(XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
+        {
+            DEBUG("xrCreateEyeTrackerHTC");
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+            eyeTracker = 0;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = (XrResult)feature.CreateEyeTracker(createInfo, out XrEyeTrackerHTC value);
+                if (result == XrResult.XR_SUCCESS) { eyeTracker = value; }
+            }
+            return result;
+        }
+        public override XrResult xrDestroyEyeTrackerHTC(XrEyeTrackerHTC eyeTracker)
+        {
+            DEBUG("xrDestroyEyeTrackerHTC");
+
+            ASSERT_FEATURE();
+            if (feature) { return (XrResult)feature.DestroyEyeTracker(eyeTracker); }
+
+            return XrResult.XR_ERROR_VALIDATION_FAILURE;
+        }
+        public override XrResult xrGetEyeGazeDataHTC(XrEyeTrackerHTC eyeTracker, XrEyeGazeDataInfoHTC gazeInfo, out XrEyeGazeDataHTC eyeGazes)
+        {
+            eyeGazes = m_eyeGazes;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = (XrResult)feature.GetEyeGazeData(eyeTracker, gazeInfo, out XrEyeGazeDataHTC gazes);
+                if (result == XrResult.XR_SUCCESS) { eyeGazes = gazes; }
+            }
+            return result;
+        }
+
+        public override bool GetEyeGazeData(out XrSingleEyeGazeDataHTC[] out_gazes)
+        {
+            out_gazes = m_eyeGazes.gaze;
+            bool result = false;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = feature.GetEyeGazeData(out XrSingleEyeGazeDataHTC[] data);
+                if (result) out_gazes = data;
+            }
+            return result;
+        }
+
+        public override XrResult xrGetEyePupilDataHTC(XrEyeTrackerHTC eyeTracker, XrEyePupilDataInfoHTC pupilDataInfo, out XrEyePupilDataHTC pupilData)
+        {
+            pupilData = m_pupilData;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = (XrResult)feature.GetEyePupilData(eyeTracker, pupilDataInfo, out XrEyePupilDataHTC data);
+                if (result == XrResult.XR_SUCCESS) { pupilData = data; }
+            }
+            return result;
+        }
+
+        public override bool GetEyePupilData(out XrSingleEyePupilDataHTC[] pupilData)
+        {
+            pupilData = m_pupilData.pupilData;
+            bool result = false;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = feature.GetEyePupilData(out XrSingleEyePupilDataHTC[] data);
+                if (result) pupilData = data;
+            }
+            return result;
+        }
+        public override XrResult xrGetEyeGeometricDataHTC(XrEyeTrackerHTC eyeTracker,
+            XrEyeGeometricDataInfoHTC info,
+            out XrEyeGeometricDataHTC eyeGeometricData)
+        {
+            eyeGeometricData = m_eyeGeometricData;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = (XrResult)feature.GetEyeGeometricData(eyeTracker, info, out XrEyeGeometricDataHTC geometricData);
+                if (result == XrResult.XR_SUCCESS) { eyeGeometricData = geometricData; }
+            }
+            return result;
+        }
+
+
+        public override bool GetEyeGeometricData(out XrSingleEyeGeometricDataHTC[] geometricData)
+        {
+            geometricData = m_eyeGeometricData.eyeGeometricData;
+            bool result = false;
+
+            ASSERT_FEATURE();
+            if (feature)
+            {
+                result = feature.GetEyeGeometricData(out XrSingleEyeGeometricDataHTC[] data);
+                if (result) geometricData = data;
+            }
+            return result;
+        }
+    }
+}