上传YomovSDK

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 673b5df0bff21a84c8b23a4f3c6a6268
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 046b5fd65fa996041a970e1fd193d213
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Documentation/OpenXRExtensions.md

@@ -0,0 +1,180 @@
+# XR_HTC_anchor XR_HTC_anchor_persistence
+## Name String
+    XR_htc_anchor XR_HTC_anchor_persistence
+## Revision
+    1
+## Overview
+
+This document provides an overview of how to use the AnchorManager to manage anchors in an OpenXR application, specifically using the XR_HTC_anchor and XR_HTC_anchor_persistence extensions.
+Introduction
+
+Anchors in OpenXR allow applications to track specific points in space over time. The XR_HTC_anchor extension provides the basic functionality for creating and managing anchors, while the XR_HTC_anchor_persistence extension allows anchors to be persisted across sessions. The AnchorManager class simplifies the use of these extensions by providing high-level methods for common operations.
+Checking Extension Support
+
+Before using any anchor-related functions, it's important to check if the extensions are supported on the current system.
+
+```csharp
+
+bool isAnchorSupported = AnchorManager.IsSupported();
+bool isPersistedAnchorSupported = AnchorManager.IsPersistedAnchorSupported();
+
+```
+
+## Creating and Managing Anchors
+### Creating an Anchor
+
+To create a new anchor, use the CreateAnchor method. This method requires a Pose representing the anchor's position and orientation relative to the tracking space, and a name for the anchor.
+
+```csharp
+
+Pose anchorPose = new Pose(new Vector3(0, 0, 0), Quaternion.identity);
+AnchorManager.Anchor newAnchor = AnchorManager.CreateAnchor(anchorPose, "MyAnchor");
+
+```
+
+### Getting an Anchor's Name
+
+To retrieve the name of an existing anchor, use the GetSpatialAnchorName method.
+
+```csharp
+
+string anchorName;
+bool success = AnchorManager.GetSpatialAnchorName(newAnchor, out anchorName);
+if (success) {
+    Debug.Log("Anchor name: " + anchorName);
+}
+
+```
+
+### Tracking Space and Pose
+
+To get the current tracking space, use the GetTrackingSpace method. To retrieve the pose of an anchor relative to the current tracking space, use the GetTrackingSpacePose method.
+
+```csharp
+
+XrSpace trackingSpace = AnchorManager.GetTrackingSpace();
+Pose anchorPose;
+bool poseValid = AnchorManager.GetTrackingSpacePose(newAnchor, out anchorPose);
+if (poseValid) {
+    Debug.Log("Anchor pose: " + anchorPose.position + ", " + anchorPose.rotation);
+}
+
+```
+
+## Persisting Anchors
+### Creating a Persisted Anchor Collection
+
+To enable anchor persistence, create a persisted anchor collection using the CreatePersistedAnchorCollection method.
+
+```csharp
+
+Task createCollectionTask = AnchorManager.CreatePersistedAnchorCollection();
+createCollectionTask.Wait();
+
+```
+
+### Persisting an Anchor
+
+To persist an anchor, use the PersistAnchor method with the anchor and a unique name for the persisted anchor.
+
+```csharp
+
+string persistedAnchorName = "MyPersistedAnchor";
+XrResult result = AnchorManager.PersistAnchor(newAnchor, persistedAnchorName);
+if (result == XrResult.XR_SUCCESS) {
+    Debug.Log("Anchor persisted successfully.");
+}
+
+```
+
+### Unpersisting an Anchor
+
+To remove a persisted anchor, use the UnpersistAnchor method with the name of the persisted anchor.
+
+```csharp
+
+XrResult result = AnchorManager.UnpersistAnchor(persistedAnchorName);
+if (result == XrResult.XR_SUCCESS) {
+    Debug.Log("Anchor unpersisted successfully.");
+}
+
+```
+
+### Enumerating Persisted Anchors
+
+To get a list of all persisted anchors, use the EnumeratePersistedAnchorNames method.
+
+```csharp
+
+string[] persistedAnchorNames;
+XrResult result = AnchorManager.EnumeratePersistedAnchorNames(out persistedAnchorNames);
+if (result == XrResult.XR_SUCCESS) {
+    foreach (var name in persistedAnchorNames) {
+        Debug.Log("Persisted anchor: " + name);
+    }
+}
+
+```
+
+### Creating an Anchor from a Persisted Anchor
+
+To create an anchor from a persisted anchor, use the CreateSpatialAnchorFromPersistedAnchor method.
+
+```csharp
+
+AnchorManager.Anchor trackableAnchor;
+XrResult result = AnchorManager.CreateSpatialAnchorFromPersistedAnchor(persistedAnchorName, "NewAnchor", out trackableAnchor);
+if (result == XrResult.XR_SUCCESS) {
+    Debug.Log("Anchor created from persisted anchor.");
+}
+
+```
+
+## Exporting and Importing Persisted Anchors
+### Exporting a Persisted Anchor
+
+To export a persisted anchor to a buffer, use the ExportPersistedAnchor method.
+
+```csharp
+
+Task<(XrResult, string, byte[])> exportTask = AnchorManager.ExportPersistedAnchor(persistedAnchorName);
+exportTask.Wait();
+var (exportResult, exportName, buffer) = exportTask.Result;
+if (exportResult == XrResult.XR_SUCCESS) {
+    // Save buffer to a file or use as needed
+    File.WriteAllBytes("anchor.pa", buffer);
+}
+
+```
+
+### Importing a Persisted Anchor
+
+To import a persisted anchor from a buffer, use the ImportPersistedAnchor method.
+
+```csharp
+
+byte[] buffer = File.ReadAllBytes("anchor.pa");
+Task<XrResult> importTask = AnchorManager.ImportPersistedAnchor(buffer);
+importTask.Wait();
+if (importTask.Result == XrResult.XR_SUCCESS) {
+    Debug.Log("Anchor imported successfully.");
+}
+
+```
+
+### Clearing Persisted Anchors
+
+To clear all persisted anchors, use the ClearPersistedAnchors method.
+
+```csharp
+
+XrResult result = AnchorManager.ClearPersistedAnchors();
+if (result == XrResult.XR_SUCCESS) {
+    Debug.Log("All persisted anchors cleared.");
+}
+
+```
+
+## Conclusion
+
+The AnchorManager class simplifies the management of anchors in OpenXR applications. By using the methods provided, you can easily create, persist, and manage anchors, ensuring that spatial data can be maintained across sessions. This document covers the basic operations; for more advanced usage, refer to the OpenXR specification and the implementation details of the AnchorManager class.

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 69ae1c3151561af42ba226f0e563ebc6
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c5cbfbcf56aaffa4fab38659c00c3903
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Scripts/ViveAnchor.cs

@@ -0,0 +1,675 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+// Remove FAKE_DATA if editor or windows is supported.
+#if UNITY_EDITOR
+#define FAKE_DATA
+#endif
+
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.Feature
+{
+    using XrPersistedAnchorCollectionHTC = System.IntPtr;
+
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Anchor (Beta)",
+        Desc = "VIVE's implementaion of the XR_HTC_anchor.",
+        Company = "HTC",
+        DocumentationLink = "..\\Documentation",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Version = "1.0.0",
+        BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
+        FeatureId = featureId
+    )]
+#endif
+    public class ViveAnchor : OpenXRFeature
+    {
+        public const string kOpenxrExtensionString = "XR_HTC_anchor XR_EXT_future XR_HTC_anchor_persistence";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.htcanchor";
+
+        /// <summary>
+        /// Enable or disable the persisted anchor feature.  Set it only valid in feature settings.
+        /// </summary>
+        public bool enablePersistedAnchor = true;
+        private XrInstance m_XrInstance = 0;
+        private XrSession session = 0;
+        private XrSystemId m_XrSystemId = 0;
+        private bool IsInited = false;
+        private bool IsPAInited = false;
+        private bool useFakeData = false;
+
+        #region struct, enum, const of this extensions
+
+        /// <summary>
+        /// An application can inspect whether the system is capable of anchor functionality by 
+        /// chaining an XrSystemAnchorPropertiesHTC structure to the XrSystemProperties when calling
+        /// xrGetSystemProperties.The runtime must return XR_ERROR_FEATURE_UNSUPPORTED if
+        /// XrSystemAnchorPropertiesHTC::supportsAnchor was XR_FALSE.
+        /// supportsAnchor indicates if current system is capable of anchor functionality.
+        /// </summary>
+        public struct XrSystemAnchorPropertiesHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public XrBool32 supportsAnchor;
+        }
+
+        /// <summary>
+        /// name is a null-terminated UTF-8 string whose length is less than or equal to XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC.
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        public struct XrSpatialAnchorNameHTC
+        {
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
+            public byte[] name;
+
+            public XrSpatialAnchorNameHTC(string anchorName)
+            {
+                name = new byte[256];
+                byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(anchorName);
+                Array.Copy(utf8Bytes, name, Math.Min(utf8Bytes.Length, 255));
+                name[255] = 0;
+            }
+
+            public XrSpatialAnchorNameHTC(XrSpatialAnchorNameHTC anchorName)
+            {
+                name = new byte[256];
+                Array.Copy(anchorName.name, name, 256);
+                name[255] = 0;
+            }
+
+            public override readonly string ToString() {
+                if (name == null)
+                    return string.Empty;
+                return System.Text.Encoding.UTF8.GetString(name).TrimEnd('\0');
+            }
+        }
+
+        public struct XrSpatialAnchorCreateInfoHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public XrSpace space;
+            public XrPosef poseInSpace;
+            public XrSpatialAnchorNameHTC name;
+        }
+
+        public struct XrPersistedAnchorCollectionAcquireInfoHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+        }
+
+        public struct XrPersistedAnchorCollectionAcquireCompletionHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public XrResult futureResult;
+            public System.IntPtr persistedAnchorCollection;
+        }
+
+        public struct XrSpatialAnchorPersistInfoHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public XrSpace anchor;
+            public XrSpatialAnchorNameHTC persistedAnchorName;
+        }
+
+        public struct XrSpatialAnchorFromPersistedAnchorCreateInfoHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public System.IntPtr persistedAnchorCollection;
+            public XrSpatialAnchorNameHTC persistedAnchorName;
+            public XrSpatialAnchorNameHTC spatialAnchorName;
+        }
+
+        public struct XrSpatialAnchorFromPersistedAnchorCreateCompletionHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public XrResult futureResult;
+            public XrSpace anchor;
+        }
+
+        public struct XrPersistedAnchorPropertiesGetInfoHTC
+        {
+            public XrStructureType type;
+            public System.IntPtr next;
+            public uint maxPersistedAnchorCount;
+        }
+
+        #endregion
+
+        #region delegates and delegate instances
+        public delegate XrResult DelegateXrCreateSpatialAnchorHTC(XrSession session, ref XrSpatialAnchorCreateInfoHTC createInfo, ref XrSpace anchor);
+        public delegate XrResult DelegateXrGetSpatialAnchorNameHTC(XrSpace anchor, ref XrSpatialAnchorNameHTC name);
+        public delegate XrResult DelegateXrAcquirePersistedAnchorCollectionAsyncHTC(XrSession session, ref XrPersistedAnchorCollectionAcquireInfoHTC acquireInfo, out IntPtr future);
+        public delegate XrResult DelegateXrAcquirePersistedAnchorCollectionCompleteHTC(IntPtr future, out XrPersistedAnchorCollectionAcquireCompletionHTC completion);
+        public delegate XrResult DelegateXrReleasePersistedAnchorCollectionHTC(IntPtr persistedAnchorCollection);
+        public delegate XrResult DelegateXrPersistSpatialAnchorAsyncHTC(XrPersistedAnchorCollectionHTC persistedAnchorCollection, ref XrSpatialAnchorPersistInfoHTC persistInfo, out IntPtr future);
+        public delegate XrResult DelegateXrPersistSpatialAnchorCompleteHTC(IntPtr future, out FutureWrapper.XrFutureCompletionEXT completion);
+        public delegate XrResult DelegateXrUnpersistSpatialAnchorHTC(IntPtr persistedAnchorCollection, ref XrSpatialAnchorNameHTC persistedAnchorName);
+        public delegate XrResult DelegateXrEnumeratePersistedAnchorNamesHTC( IntPtr persistedAnchorCollection, uint persistedAnchorNameCapacityInput, ref uint persistedAnchorNameCountOutput, [Out] XrSpatialAnchorNameHTC[] persistedAnchorNames);
+        public delegate XrResult DelegateXrCreateSpatialAnchorFromPersistedAnchorAsyncHTC(XrSession session, ref XrSpatialAnchorFromPersistedAnchorCreateInfoHTC spatialAnchorCreateInfo, out IntPtr future);
+        public delegate XrResult DelegateXrCreateSpatialAnchorFromPersistedAnchorCompleteHTC(IntPtr future, out XrSpatialAnchorFromPersistedAnchorCreateCompletionHTC completion);
+        public delegate XrResult DelegateXrClearPersistedAnchorsHTC(IntPtr persistedAnchorCollection);
+        public delegate XrResult DelegateXrGetPersistedAnchorPropertiesHTC(IntPtr persistedAnchorCollection, ref XrPersistedAnchorPropertiesGetInfoHTC getInfo);
+        public delegate XrResult DelegateXrExportPersistedAnchorHTC(IntPtr persistedAnchorCollection, ref XrSpatialAnchorNameHTC persistedAnchorName, uint dataCapacityInput, ref uint dataCountOutput, [Out] byte[] data);
+        public delegate XrResult DelegateXrImportPersistedAnchorHTC(IntPtr persistedAnchorCollection, uint dataCount, [In] byte[] data);
+        public delegate XrResult DelegateXrGetPersistedAnchorNameFromBufferHTC(IntPtr persistedAnchorCollection, uint bufferCount, byte[] buffer, ref XrSpatialAnchorNameHTC name);
+
+        DelegateXrCreateSpatialAnchorHTC XrCreateSpatialAnchorHTC;
+        DelegateXrGetSpatialAnchorNameHTC XrGetSpatialAnchorNameHTC;
+        DelegateXrAcquirePersistedAnchorCollectionAsyncHTC XrAcquirePersistedAnchorCollectionAsyncHTC;
+        DelegateXrAcquirePersistedAnchorCollectionCompleteHTC XrAcquirePersistedAnchorCollectionCompleteHTC;
+        DelegateXrReleasePersistedAnchorCollectionHTC XrReleasePersistedAnchorCollectionHTC;
+        DelegateXrPersistSpatialAnchorAsyncHTC XrPersistSpatialAnchorAsyncHTC;
+        DelegateXrPersistSpatialAnchorCompleteHTC XrPersistSpatialAnchorCompleteHTC;
+        DelegateXrUnpersistSpatialAnchorHTC XrUnpersistSpatialAnchorHTC;
+        DelegateXrEnumeratePersistedAnchorNamesHTC XrEnumeratePersistedAnchorNamesHTC;
+        DelegateXrCreateSpatialAnchorFromPersistedAnchorAsyncHTC XrCreateSpatialAnchorFromPersistedAnchorAsyncHTC;
+        DelegateXrCreateSpatialAnchorFromPersistedAnchorCompleteHTC XrCreateSpatialAnchorFromPersistedAnchorCompleteHTC;
+        DelegateXrClearPersistedAnchorsHTC XrClearPersistedAnchorsHTC;
+        DelegateXrGetPersistedAnchorPropertiesHTC XrGetPersistedAnchorPropertiesHTC;
+        DelegateXrExportPersistedAnchorHTC XrExportPersistedAnchorHTC;
+        DelegateXrImportPersistedAnchorHTC XrImportPersistedAnchorHTC;
+        DelegateXrGetPersistedAnchorNameFromBufferHTC XrGetPersistedAnchorNameFromBufferHTC;
+
+        #endregion delegates and delegate instances
+
+        #region override functions
+
+        protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+        {
+            // For LocateSpace, need WaitFrame's predictedDisplayTime.
+            ViveInterceptors.Instance.AddRequiredFunction("xrWaitFrame");
+            return ViveInterceptors.Instance.HookGetInstanceProcAddr(func);
+        }
+
+        /// <inheritdoc />
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+#if FAKE_DATA
+            Debug.LogError("ViveAnchor OnInstanceCreate() Use FakeData");
+            useFakeData = true;
+#endif
+            IsInited = false;
+            bool ret = true;
+            ret &= CommonWrapper.Instance.OnInstanceCreate(xrInstance, xrGetInstanceProcAddr);
+            ret &= SpaceWrapper.Instance.OnInstanceCreate(xrInstance, xrGetInstanceProcAddr);
+
+            if (!ret)
+            {
+                Debug.LogError("ViveAnchor OnInstanceCreate() failed.");
+                return false;
+            }
+
+            //Debug.Log("VIVEAnchor OnInstanceCreate() ");
+            if (!OpenXRRuntime.IsExtensionEnabled("XR_HTC_anchor") && !useFakeData)
+            {
+                Debug.LogWarning("ViveAnchor OnInstanceCreate() XR_HTC_anchor is NOT enabled.");
+                return false;
+            }
+
+            IsInited = GetXrFunctionDelegates(xrInstance);
+
+            if (!IsInited)
+            {
+                Debug.LogError("ViveAnchor OnInstanceCreate() failed to get function delegates.");
+                return false;
+            }
+
+            m_XrInstance = xrInstance;
+
+            bool hasFuture = FutureWrapper.Instance.OnInstanceCreate(xrInstance, xrGetInstanceProcAddr);
+            // No error log because future will print.
+#if FAKE_DATA
+            hasFuture = true;
+#endif
+            IsPAInited = false;
+            bool hasPersistedAnchor = false;
+            do
+            {
+                if (!hasFuture)
+                {
+                    Debug.LogWarning("ViveAnchor OnInstanceCreate() XR_HTC_anchor_persistence is NOT enabled because no XR_EXT_future.");
+                    hasPersistedAnchor = false;
+                    break;
+                }
+
+                hasPersistedAnchor = enablePersistedAnchor && OpenXRRuntime.IsExtensionEnabled("XR_HTC_anchor_persistence");
+#if FAKE_DATA
+                hasPersistedAnchor = enablePersistedAnchor;
+#endif
+            } while(false);
+
+            //Debug.Log("OnInstanceCreate() " + m_XrInstance);
+            if (hasPersistedAnchor)
+                IsPAInited = GetXrFunctionDelegatesPersistance(xrInstance);
+            if (!IsPAInited)
+                Debug.LogWarning("ViveAnchor OnInstanceCreate() XR_HTC_anchor_persistence is NOT enabled.");
+
+            return IsInited;
+        }
+
+        protected override void OnInstanceDestroy(ulong xrInstance)
+        {
+            m_XrInstance = 0;
+
+            IsInited = false;
+            IsPAInited = false;
+
+            CommonWrapper.Instance.OnInstanceDestroy();
+            SpaceWrapper.Instance.OnInstanceDestroy();
+            FutureWrapper.Instance.OnInstanceDestroy();
+            Debug.Log("ViveAnchor: OnInstanceDestroy()");
+        }
+
+        /// <inheritdoc />
+        protected override void OnSessionCreate(ulong xrSession)
+        {
+            //Debug.Log("ViveAnchor OnSessionCreate() ");
+            session = xrSession;
+        }
+
+        /// <inheritdoc />
+        protected override void OnSessionDestroy(ulong xrSession)
+        {
+            //Debug.Log("ViveAnchor OnSessionDestroy() ");
+            session = 0;
+        }
+
+        // XXX Every millisecond the AppSpace switched from one space to another space. I don't know what is going on.
+        //private ulong appSpace;
+        //protected override void OnAppSpaceChange(ulong space)
+        //{
+        //    //Debug.Log($"VIVEAnchor OnAppSpaceChange({appSpace} -> {space})");
+        //    appSpace = space;
+        //}
+
+        /// <inheritdoc />
+        protected override void OnSystemChange(ulong xrSystem)
+        {
+            m_XrSystemId = xrSystem;
+            //Debug.Log("ViveAnchor OnSystemChange() " + m_XrSystemId);
+        }
+
+        #endregion override functions
+
+        private bool GetXrFunctionDelegates(XrInstance inst)
+        {
+            Debug.Log("ViveAnchor GetXrFunctionDelegates() ");
+
+            bool ret = true;
+            OpenXRHelper.xrGetInstanceProcAddrDelegate GetAddr = CommonWrapper.Instance.GetInstanceProcAddr;  // shorter name
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrCreateSpatialAnchorHTC", out XrCreateSpatialAnchorHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrGetSpatialAnchorNameHTC", out XrGetSpatialAnchorNameHTC);
+
+            return ret;
+        }
+
+        private bool GetXrFunctionDelegatesPersistance(XrInstance inst)
+        {
+            Debug.Log("ViveAnchor GetXrFunctionDelegatesPersistance() ");
+            bool ret = true;
+            OpenXRHelper.xrGetInstanceProcAddrDelegate GetAddr = CommonWrapper.Instance.GetInstanceProcAddr;  // shorter name
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrAcquirePersistedAnchorCollectionAsyncHTC", out XrAcquirePersistedAnchorCollectionAsyncHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrAcquirePersistedAnchorCollectionCompleteHTC", out XrAcquirePersistedAnchorCollectionCompleteHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrReleasePersistedAnchorCollectionHTC", out XrReleasePersistedAnchorCollectionHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrPersistSpatialAnchorAsyncHTC", out XrPersistSpatialAnchorAsyncHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrPersistSpatialAnchorCompleteHTC", out XrPersistSpatialAnchorCompleteHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrUnpersistSpatialAnchorHTC", out XrUnpersistSpatialAnchorHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrEnumeratePersistedAnchorNamesHTC", out XrEnumeratePersistedAnchorNamesHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrCreateSpatialAnchorFromPersistedAnchorAsyncHTC", out XrCreateSpatialAnchorFromPersistedAnchorAsyncHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrCreateSpatialAnchorFromPersistedAnchorCompleteHTC", out XrCreateSpatialAnchorFromPersistedAnchorCompleteHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrClearPersistedAnchorsHTC", out XrClearPersistedAnchorsHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrGetPersistedAnchorPropertiesHTC", out XrGetPersistedAnchorPropertiesHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrExportPersistedAnchorHTC", out XrExportPersistedAnchorHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrImportPersistedAnchorHTC", out XrImportPersistedAnchorHTC);
+            ret &= OpenXRHelper.GetXrFunctionDelegate(GetAddr, inst, "xrGetPersistedAnchorNameFromBufferHTC", out XrGetPersistedAnchorNameFromBufferHTC);
+
+            return ret;
+        }
+
+        #region functions of extension
+        /// <summary>
+        /// Helper function to get this feature's properties.
+        /// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>
+        /// </summary>
+        /// <param name="anchorProperties">Output parameter to hold anchor properties.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult GetProperties(out XrSystemAnchorPropertiesHTC anchorProperties)
+        {
+            anchorProperties = new XrSystemAnchorPropertiesHTC();
+            anchorProperties.type = XrStructureType.XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC;
+
+#if FAKE_DATA
+            if (Application.isEditor)
+            {
+                anchorProperties.type = XrStructureType.XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC;
+                anchorProperties.supportsAnchor = true;
+                return XrResult.XR_SUCCESS;
+            }
+#endif
+            return CommonWrapper.Instance.GetProperties(m_XrInstance, m_XrSystemId, ref anchorProperties);
+        }
+
+        /// <summary>
+        /// The CreateSpatialAnchor function creates a spatial anchor with specified base space and pose in the space.
+        /// The anchor is represented by an XrSpace and its pose can be tracked via xrLocateSpace.
+        /// Once the anchor is no longer needed, call xrDestroySpace to erase the anchor.
+        /// </summary>
+        /// <param name="createInfo">Information required to create the spatial anchor.</param>
+        /// <param name="anchor">Output parameter to hold the created anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult CreateSpatialAnchor(XrSpatialAnchorCreateInfoHTC createInfo, out XrSpace anchor)
+        {
+            anchor = default;
+            if (!IsInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            if (session == 0)
+                return XrResult.XR_ERROR_SESSION_LOST;
+
+            var ret = XrCreateSpatialAnchorHTC(session, ref createInfo, ref anchor);
+            //Debug.Log("ViveAnchor CreateSpatialAnchor() r=" + ret + ", a=" + anchor + ", bs=" + createInfo.space +
+            //    ", pos=(" + createInfo.poseInSpace.position.x + "," + createInfo.poseInSpace.position.y + "," + createInfo.poseInSpace.position.z +
+            //    "), rot=(" + createInfo.poseInSpace.orientation.x + "," + createInfo.poseInSpace.orientation.y + "," + createInfo.poseInSpace.orientation.z + "," + createInfo.poseInSpace.orientation.w +
+            //    "), n=" + createInfo.name.name);
+            return ret;
+        }
+
+        /// <summary>
+        /// The GetSpatialAnchorName function retrieves the name of the spatial anchor.
+        /// </summary>
+        /// <param name="anchor">The XrSpace representing the anchor.</param>
+        /// <param name="name">Output parameter to hold the name of the anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult GetSpatialAnchorName(XrSpace anchor, out XrSpatialAnchorNameHTC name)
+        {
+            name = new XrSpatialAnchorNameHTC();
+            if (!IsInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            return XrGetSpatialAnchorNameHTC(anchor, ref name);
+        }
+
+        /// <summary>
+        /// If the extension is supported and enabled, return true.
+        /// </summary>
+        /// <returns>True if persisted anchor extension is supported, false otherwise.</returns>
+        public bool IsPersistedAnchorSupported()
+        {
+            return IsPAInited;
+        }
+
+        /// <summary>
+        /// Creates a persisted anchor collection.  This collection can be used to persist spatial anchors across sessions.
+        /// Many persisted anchor APIs need a persisted anchor collection to operate.
+        /// </summary>
+        /// <param name="future">Output the async future handle.  Check the future to get the PersitedAnchorCollection handle.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult AcquirePersistedAnchorCollectionAsync(out IntPtr future)
+        {
+            future = IntPtr.Zero;
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            if (session == 0)
+                return XrResult.XR_ERROR_SESSION_LOST;
+
+            XrPersistedAnchorCollectionAcquireInfoHTC acquireInfo = new XrPersistedAnchorCollectionAcquireInfoHTC
+            {
+                type = XrStructureType.XR_TYPE_PERSISTED_ANCHOR_COLLECTION_ACQUIRE_INFO_HTC,
+                next = IntPtr.Zero,
+            };
+
+            return XrAcquirePersistedAnchorCollectionAsyncHTC(session, ref acquireInfo, out future);
+        }
+
+        public XrResult AcquirePersistedAnchorCollectionComplete(IntPtr future, out XrPersistedAnchorCollectionAcquireCompletionHTC completion)
+        {
+            completion = new XrPersistedAnchorCollectionAcquireCompletionHTC();
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrAcquirePersistedAnchorCollectionCompleteHTC(future, out completion);
+        }
+
+            
+
+        /// <summary>
+        /// Destroys the persisted anchor collection.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to be destroyed.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult ReleasePersistedAnchorCollection(IntPtr persistedAnchorCollection)
+        {
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrReleasePersistedAnchorCollectionHTC(persistedAnchorCollection);
+        }
+
+        /// <summary>
+        /// Persists a spatial anchor with the given name.  The name should be unique.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="anchor">The spatial anchor to be persisted.</param>
+        /// <param name="name">The name of the persisted anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult PersistSpatialAnchorAsync(IntPtr persistedAnchorCollection, XrSpace anchor, XrSpatialAnchorNameHTC name, out IntPtr future)
+        {
+            future = IntPtr.Zero;
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            XrSpatialAnchorPersistInfoHTC persistInfo = new XrSpatialAnchorPersistInfoHTC
+            {
+                type = XrStructureType.XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_HTC,
+                anchor = anchor,
+                persistedAnchorName = name
+            };
+            return XrPersistSpatialAnchorAsyncHTC(persistedAnchorCollection, ref persistInfo, out future);
+        }
+
+        public XrResult PersistSpatialAnchorComplete(IntPtr future, out FutureWrapper.XrFutureCompletionEXT completion)
+        {
+            completion = new FutureWrapper.XrFutureCompletionEXT() {
+                type = XrStructureType.XR_TYPE_FUTURE_COMPLETION_EXT,
+                next = IntPtr.Zero,
+                futureResult = XrResult.XR_SUCCESS
+            };
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrPersistSpatialAnchorCompleteHTC(future, out completion);
+        }
+
+        /// <summary>
+        /// Unpersists the anchor with the given name.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="name">The name of the anchor to be unpersisted.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult UnpersistSpatialAnchor(IntPtr persistedAnchorCollection, XrSpatialAnchorNameHTC name)
+        {
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrUnpersistSpatialAnchorHTC(persistedAnchorCollection, ref name);
+        }
+
+        /// <summary>
+        /// Enumerates all persisted anchor names.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="persistedAnchorNameCapacityInput">The capacity of the input buffer.</param>
+        /// <param name="persistedAnchorNameCountOutput">Output parameter to hold the count of persisted anchor names.</param>
+        /// <param name="persistedAnchorNames">Output parameter to hold the names of persisted anchors.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult EnumeratePersistedAnchorNames(IntPtr persistedAnchorCollection, uint persistedAnchorNameCapacityInput,
+            ref uint persistedAnchorNameCountOutput, ref XrSpatialAnchorNameHTC[] persistedAnchorNames)
+        {
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrEnumeratePersistedAnchorNamesHTC(persistedAnchorCollection, persistedAnchorNameCapacityInput, ref persistedAnchorNameCountOutput, persistedAnchorNames);
+        }
+
+        /// <summary>
+        /// Creates a spatial anchor from a persisted anchor.
+        /// </summary>
+        /// <param name="spatialAnchorCreateInfo">Information required to create the spatial anchor from persisted anchor.</param>
+        /// <param name="anchor">Output parameter to hold the created spatial anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult CreateSpatialAnchorFromPersistedAnchorAsync(XrSpatialAnchorFromPersistedAnchorCreateInfoHTC spatialAnchorCreateInfo, out IntPtr future)
+        {
+            future = IntPtr.Zero;
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            if (session == 0)
+                return XrResult.XR_ERROR_SESSION_LOST;
+            return XrCreateSpatialAnchorFromPersistedAnchorAsyncHTC(session, ref spatialAnchorCreateInfo, out future);
+        }
+
+        /// <summary>
+        /// When the future is ready, call this function to get the result.
+        /// </summary>
+        /// <param name="future"></param>
+        /// <param name="completion"></param>
+        /// <returns></returns>
+        public XrResult CreateSpatialAnchorFromPersistedAnchorComplete(IntPtr future, out XrSpatialAnchorFromPersistedAnchorCreateCompletionHTC completion)
+        {
+            completion = new XrSpatialAnchorFromPersistedAnchorCreateCompletionHTC()
+            {
+                type = XrStructureType.XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_COMPLETION_HTC,
+                next = IntPtr.Zero,
+                futureResult = XrResult.XR_SUCCESS,
+                anchor = 0
+            };
+
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            return XrCreateSpatialAnchorFromPersistedAnchorCompleteHTC(future, out completion);
+        }
+
+        /// <summary>
+        /// Clears all persisted anchors.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult ClearPersistedAnchors(IntPtr persistedAnchorCollection)
+        {
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            return XrClearPersistedAnchorsHTC(persistedAnchorCollection);
+        }
+
+        /// <summary>
+        /// Gets the properties of the persisted anchor.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="getInfo">Output parameter to hold the properties of the persisted anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult GetPersistedAnchorProperties(IntPtr persistedAnchorCollection, out XrPersistedAnchorPropertiesGetInfoHTC getInfo)
+        {
+            getInfo = new XrPersistedAnchorPropertiesGetInfoHTC
+            {
+                type = XrStructureType.XR_TYPE_PERSISTED_ANCHOR_PROPERTIES_GET_INFO_HTC
+            };
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            return XrGetPersistedAnchorPropertiesHTC(persistedAnchorCollection, ref getInfo);
+        }
+
+        /// <summary>
+        /// Exports the persisted anchor to a buffer. The buffer can be used to import the anchor later or save to a file.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="persistedAnchorName">The name of the persisted anchor to be exported.</param>
+        /// <param name="data">Output parameter to hold the buffer containing the exported anchor.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult ExportPersistedAnchor(IntPtr persistedAnchorCollection, XrSpatialAnchorNameHTC persistedAnchorName, out byte[] data)
+        {
+            data = null;
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+            uint dataCountOutput = 0;
+            uint dataCapacityInput = 0;
+            XrResult ret = XrExportPersistedAnchorHTC(persistedAnchorCollection, ref persistedAnchorName, dataCapacityInput, ref dataCountOutput, null);
+            if (ret != XrResult.XR_SUCCESS)
+            {
+                Debug.LogError("ExportPersistedAnchor failed to get data size. ret=" + ret);
+                data = null;
+                return ret;
+            }
+
+            dataCapacityInput = dataCountOutput;
+            data = new byte[dataCountOutput];
+            ret = XrExportPersistedAnchorHTC(persistedAnchorCollection, ref persistedAnchorName, dataCapacityInput, ref dataCountOutput, data);
+            return ret;
+        }
+
+        /// <summary>
+        /// Imports the persisted anchor from a buffer. The buffer should be created by ExportPersistedAnchor.
+        /// </summary>
+        /// <param name="persistedAnchorCollection">The persisted anchor collection to operate.</param>
+        /// <param name="data">The buffer containing the persisted anchor data.</param>
+        /// <returns>XrResult indicating success or failure.</returns>
+        public XrResult ImportPersistedAnchor(IntPtr persistedAnchorCollection, byte[] data)
+        {
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            return XrImportPersistedAnchorHTC(persistedAnchorCollection, (uint)data.Length, data);
+        }
+
+        /// <summary>
+        /// Gets the name of the persisted anchor from a buffer. The buffer should be created by ExportPersistedAnchor.
+        /// </summary>
+        /// <param name="persistedAnchorCollection"></param>
+        /// <param name="buffer"></param>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public XrResult GetPersistedAnchorNameFromBuffer(IntPtr persistedAnchorCollection, byte[] buffer, out XrSpatialAnchorNameHTC name)
+        {
+            name = new XrSpatialAnchorNameHTC();
+            if (!IsPAInited)
+                return XrResult.XR_ERROR_EXTENSION_NOT_PRESENT;
+
+            if (buffer == null)
+                return XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            return XrGetPersistedAnchorNameFromBufferHTC(persistedAnchorCollection, (uint)buffer.Length, buffer, ref name);
+        }
+
+        #endregion
+
+        #region tools for user
+
+        /// <summary>
+        /// According to XRInputSubsystem's tracking origin mode, return the corresponding XrSpace.
+        /// </summary>
+        /// <returns></returns>
+        public XrSpace GetTrackingSpace()
+        {
+            var s = GetCurrentAppSpace();
+            //Debug.Log("ViveAnchor GetTrackingSpace() s=" + s);
+            return s;
+        }
+        #endregion
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/Anchor/Scripts/ViveAnchor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c17aa731a6f4fb54bb9a2c28df667e5e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4126580e0f3096546977cff4f5203eb1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1850b50609fc1db458be9f8f11c62852
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Documentation/OpenXRExtensions.md

@@ -0,0 +1,24 @@
+# 12.7. XR_KHR_composition_layer_cylinder
+## Name String
+    XR_KHR_composition_layer_cylinder
+## Revision
+    4
+## New Object Types
+## New Enum Constants
+[XrStructureType](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrStructureType) enumeration is extended with:
+- XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR
+## New Enums
+## New Structures
+- [XrCompositionLayerCylinderKHR ](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerCylinderKHR)
+## New Functions
+
+## VIVE Plugin
+
+Enable "VIVE XR Composition Layer" in "Project Settings > XR Plugin-in Management > OpenXR > Android Tab > OpenXR Feature Groups" in order to use the Composition Layer feature provided by the VIVE plugin.
+
+The plugin provides scripts and resources for setting up Composition Layers quickly and easily.
+There are two scripts which can be attached to **GameObjects**:
+- CompositionLayer: For setting up a basic Composition Layer. Located at: *\<VIVE OpenXR path\>/Runtime/CompositionLayer/Scripts/CompositionLayer.cs*
+- CompositionLayerUICanvas: For setting up a Composition Layer which renders a Unity UI Canvas. Located at: *\<VIVE OpenXR path\>/Runtime/CompositionLayer/Scripts/CompositionLayerUICanvas.cs*
+
+To see how the two scripts above can be used, refer to the samples located at: *\<VIVE OpenXR sample path\>/CompositionLayer/Scenes*

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cbab5ef182d5d34438925945775e2443
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f29d9246fa53ed5469160eb0ec165fb8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayer.cs

@@ -0,0 +1,570 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using AOT;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer",
+		Desc = "Enable this feature to use the Composition Layer.",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenxrExtensionStrings,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		FeatureId = featureId
+	)]
+#endif
+	public class ViveCompositionLayer : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayer";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// Enable auto fallback or Not.
+		/// </summary>
+		public bool enableAutoFallback = false;
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer";
+
+		public const string kOpenxrExtensionStrings = "";
+
+		#region OpenXR Life Cycle
+		private bool m_XrInstanceCreated = false;
+		/// <summary>
+		/// The XR instance is created or not.
+		/// </summary>
+		public bool XrInstanceCreated
+		{
+			get { return m_XrInstanceCreated; }
+		}
+		private XrInstance m_XrInstance = 0;
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			foreach (string kOpenxrExtensionString in kOpenxrExtensionStrings.Split(' '))
+			{
+				if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+				{
+					WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+				}
+			}
+
+			m_XrInstanceCreated = true;
+			m_XrInstance = xrInstance;
+			DEBUG("OnInstanceCreate() " + m_XrInstance);
+
+			return GetXrFunctionDelegates(m_XrInstance);
+		}
+
+		protected override void OnInstanceDestroy(ulong xrInstance)
+		{
+			m_XrInstanceCreated = false;
+			DEBUG("OnInstanceDestroy() " + m_XrInstance);
+		}
+
+		private XrSystemId m_XrSystemId = 0;
+		protected override void OnSystemChange(ulong xrSystem)
+		{
+			m_XrSystemId = xrSystem;
+			DEBUG("OnSystemChange() " + m_XrSystemId);
+		}
+
+		private bool m_XrSessionCreated = false;
+		/// <summary>
+		/// The XR session is created or not.
+		/// </summary>
+		public bool XrSessionCreated
+		{
+			get { return m_XrSessionCreated; }
+		}
+		private XrSession m_XrSession = 0;
+		protected override void OnSessionCreate(ulong xrSession)
+		{
+			m_XrSession = xrSession;
+			m_XrSessionCreated = true;
+			DEBUG("OnSessionCreate() " + m_XrSession);
+		}
+
+		private bool m_XrSessionEnding = false;
+		/// <summary>
+		/// The XR session is ending or not.
+		/// </summary>
+		public bool XrSessionEnding
+		{
+			get { return m_XrSessionEnding; }
+		}
+
+		private XrSpace m_WorldLockSpaceOriginOnHead = 0, m_WorldLockSpaceOriginOnFloor = 0, m_HeadLockSpace = 0;
+		/// <summary>
+		/// The XrSpace of world lock space origin on head.
+		/// </summary>
+		public XrSpace WorldLockSpaceOriginOnHead
+		{
+			get { return m_WorldLockSpaceOriginOnHead; }
+		}
+		/// <summary>
+		/// The XrSpace of world lock space origin on floor.
+		/// </summary>
+		public XrSpace WorldLockSpaceOriginOnFloor
+		{
+			get { return m_WorldLockSpaceOriginOnFloor; }
+		}
+		/// <summary>
+		/// The XrSpace of head lock space.
+		/// </summary>
+		public XrSpace HeadLockSpace
+		{
+			get { return m_HeadLockSpace; }
+		}
+
+		protected override void OnSessionBegin(ulong xrSession)
+		{
+			m_XrSessionEnding = false;
+			DEBUG("OnSessionBegin() " + m_XrSession);
+
+			// Enumerate supported reference space types and create the XrSpace.
+			XrReferenceSpaceType[] spaces = new XrReferenceSpaceType[Enum.GetNames(typeof(XrReferenceSpaceType)).Count()];
+			UInt32 spaceCountOutput;
+			if (EnumerateReferenceSpaces(
+				spaceCapacityInput: 0,
+				spaceCountOutput: out spaceCountOutput,
+				spaces: out spaces[0]) == XrResult.XR_SUCCESS)
+			{
+				//DEBUG("spaceCountOutput: " + spaceCountOutput);
+
+				Array.Resize(ref spaces, (int)spaceCountOutput);
+				if (EnumerateReferenceSpaces(
+					spaceCapacityInput: spaceCountOutput,
+					spaceCountOutput: out spaceCountOutput,
+					spaces: out spaces[0]) == XrResult.XR_SUCCESS)
+				{
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
+						referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL;
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoWorldLock,
+						space: out m_WorldLockSpaceOriginOnHead) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnHead);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for world lock layers on head failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for world lock on head layers.");
+					}
+
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
+						referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE;
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoWorldLock,
+						space: out m_WorldLockSpaceOriginOnFloor) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnFloor);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for world lock layers on floor failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for world lock on floor layers.");
+					}
+
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoHeadLock;
+						referenceSpaceCreateInfoHeadLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoHeadLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoHeadLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW;
+						referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoHeadLock,
+						space: out m_HeadLockSpace) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_HeadLockSpace);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for head lock layers failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for head lock layers.");
+					}
+				}
+				else
+				{
+					ERROR("EnumerateReferenceSpaces(" + spaceCountOutput + ") failed.");
+				}
+			}
+			else
+			{
+				ERROR("EnumerateReferenceSpaces(0) failed.");
+			}
+		}
+
+		protected override void OnSessionEnd(ulong xrSession)
+		{
+			m_XrSessionEnding = true;
+			DEBUG("OnSessionEnd() " + m_XrSession);
+		}
+
+
+		protected override void OnSessionDestroy(ulong xrSession)
+		{
+			m_XrSessionCreated = false;
+			DEBUG("OnSessionDestroy() " + xrSession);
+
+			if (m_HeadLockSpace != 0)
+			{
+				DestroySpace(m_HeadLockSpace);
+				m_HeadLockSpace = 0;
+			}
+			if (m_WorldLockSpaceOriginOnFloor != 0)
+			{
+				DestroySpace(m_WorldLockSpaceOriginOnFloor);
+				m_WorldLockSpaceOriginOnFloor = 0;
+			}
+			if (m_WorldLockSpaceOriginOnHead != 0)
+			{
+				DestroySpace(m_WorldLockSpaceOriginOnHead);
+				m_WorldLockSpaceOriginOnHead = 0;
+			}
+		}
+
+		/// <summary>
+		/// The current XR Session state.
+		/// </summary>
+		public XrSessionState XrSessionCurrentState
+		{
+			get { return m_XrSessionNewState; }
+		}
+		private XrSessionState m_XrSessionNewState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
+		private XrSessionState m_XrSessionOldState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
+		protected override void OnSessionStateChange(int oldState, int newState)
+		{
+			DEBUG("OnSessionStateChange() oldState: " + oldState + " newState:" + newState);
+
+			if (Enum.IsDefined(typeof(XrSessionState), oldState))
+			{
+				m_XrSessionOldState = (XrSessionState)oldState;
+			}
+			else
+			{
+				DEBUG("OnSessionStateChange() oldState undefined");
+			}
+
+			if (Enum.IsDefined(typeof(XrSessionState), newState)) 
+			{
+				m_XrSessionNewState = (XrSessionState)newState;
+			}
+			else
+			{
+				DEBUG("OnSessionStateChange() newState undefined");
+			}
+			
+		}
+		#endregion
+
+		#region OpenXR function delegates
+		/// xrGetInstanceProcAddr
+		OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+
+		/// xrGetSystemProperties
+		OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
+		/// <summary>
+		/// Helper function to get this feature' properties.
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>
+		/// </summary>
+		public XrResult GetSystemProperties(ref XrSystemProperties properties)
+		{
+			if (m_XrInstanceCreated)
+			{
+				return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
+			}
+
+			return XrResult.XR_ERROR_INSTANCE_LOST;
+		}
+
+		/// xrEnumerateReferenceSpaces
+		OpenXRHelper.xrEnumerateReferenceSpacesDelegate xrEnumerateReferenceSpaces;
+		/// <summary>
+		/// Enumerate available reference spaces
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrEnumerateReferenceSpaces.html">xrEnumerateReferenceSpaces</see>
+		/// </summary>
+		public XrResult EnumerateReferenceSpaces(UInt32 spaceCapacityInput, out UInt32 spaceCountOutput, out XrReferenceSpaceType spaces)
+		{
+			if (!m_XrSessionCreated)
+			{
+				spaceCountOutput = 0;
+				spaces = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT;
+				return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
+			}
+
+			return xrEnumerateReferenceSpaces(m_XrSession, spaceCapacityInput, out spaceCountOutput, out spaces);
+		}
+
+		/// xrCreateReferenceSpace
+		OpenXRHelper.xrCreateReferenceSpaceDelegate xrCreateReferenceSpace;
+		/// <summary>
+		/// Creates a reference space
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrCreateReferenceSpace.html">xrCreateReferenceSpace</see>
+		/// </summary>
+		public XrResult CreateReferenceSpace(ref XrReferenceSpaceCreateInfo createInfo, out XrSpace space)
+		{
+			if (!m_XrSessionCreated)
+			{
+				space = 0;
+				return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
+			}
+
+			return xrCreateReferenceSpace(m_XrSession, ref createInfo, out space);
+		}
+
+		/// xrDestroySpace
+		OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
+		/// <summary>
+		/// Destroys an XrSpace
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrDestroySpace.html">xrDestroySpace</see>
+		/// </summary>
+		public XrResult DestroySpace(XrSpace space)
+		{
+			if (space != 0)
+			{
+				return xrDestroySpace(space);
+			}
+			return XrResult.XR_ERROR_REFERENCE_SPACE_UNSUPPORTED;
+		}
+
+		private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            /// xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                DEBUG("Get function pointer of xrGetInstanceProcAddr.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                    xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+            }
+            else
+            {
+                ERROR("xrGetInstanceProcAddr");
+                return false;
+            }
+
+            IntPtr funcPtr = IntPtr.Zero;
+            /// xrGetSystemProperties
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetSystemProperties.");
+                    xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetSystemProperties");
+                return false;
+            }
+			/// xrEnumerateReferenceSpaces
+			if (XrGetInstanceProcAddr(xrInstance, "xrEnumerateReferenceSpaces", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrEnumerateReferenceSpaces.");
+					xrEnumerateReferenceSpaces = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrEnumerateReferenceSpacesDelegate)) as OpenXRHelper.xrEnumerateReferenceSpacesDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrEnumerateReferenceSpaces");
+				return false;
+			}
+			/// xrCreateReferenceSpace
+			if (XrGetInstanceProcAddr(xrInstance, "xrCreateReferenceSpace", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrCreateReferenceSpace.");
+					xrCreateReferenceSpace = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrCreateReferenceSpaceDelegate)) as OpenXRHelper.xrCreateReferenceSpaceDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrCreateReferenceSpace");
+				return false;
+			}
+			/// xrDestroySpace
+			if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrDestroySpace.");
+					xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrDestroySpace");
+				return false;
+			}
+
+			if (CompositionLayer_GetFuncAddrs(xrInstance, xrGetInstanceProcAddr) == XrResult.XR_SUCCESS)
+			{
+				DEBUG("Get function pointers in native.");
+			}
+			else
+			{
+				ERROR("CompositionLayer_GetFuncAddrs");
+				return false;
+			}
+
+			return true;
+        }
+		#endregion
+
+		#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_GetExternalSurfaceObj")]
+		public static extern IntPtr VIVEOpenXR_Compositionlayer_GetExternalSurfaceObj();
+		public IntPtr Compositionlayer_GetExternalSurfaceObj()
+		{
+			return VIVEOpenXR_Compositionlayer_GetExternalSurfaceObj();
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_GetExternalSurfaceObj2")]
+		public static extern IntPtr VIVEOpenXR_Compositionlayer_GetExternalSurfaceObj2(int layerID);
+		public IntPtr Compositionlayer_GetExternalSurfaceObj2(int layerID)
+		{
+			return VIVEOpenXR_Compositionlayer_GetExternalSurfaceObj2(layerID);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_Init")]
+		public static extern int VIVEOpenXR_CompositionLayer_Init(XrSession session, uint textureWidth, uint textureHeight, GraphicsAPI graphicsAPI, bool isDynamic, bool isProtected, out uint imageCount, bool isExternal);
+		/// <summary>
+		/// Init composion layer.
+		/// </summary>
+		public int CompositionLayer_Init(uint textureWidth, uint textureHeight, GraphicsAPI graphicsAPI, bool isDynamic, bool isProtected, out uint imageCount, bool isExternal = false)
+		{
+			if (!m_XrSessionCreated)
+			{
+				ERROR("Xr Session not found");
+				imageCount = 0;
+				return 0;
+			}
+
+			return VIVEOpenXR_CompositionLayer_Init(m_XrSession, textureWidth, textureHeight, graphicsAPI, isDynamic, isProtected, out imageCount, isExternal);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_GetTexture")]
+		public static extern IntPtr VIVEOpenXR_CompositionLayer_GetTexture(int layerID, out uint imageIndex);
+		/// <summary>
+		/// Get composition layer texture.
+		/// </summary>
+		public IntPtr CompositionLayer_GetTexture(int layerID, out uint imageIndex)
+		{
+			return VIVEOpenXR_CompositionLayer_GetTexture(layerID, out imageIndex);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_ReleaseTexture")]
+		public static extern bool VIVEOpenXR_CompositionLayer_ReleaseTexture(int layerID);
+		/// <summary>
+		/// release composition layer texture.
+		/// </summary>
+		public bool CompositionLayer_ReleaseTexture(int layerID)
+		{
+			return VIVEOpenXR_CompositionLayer_ReleaseTexture(layerID);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_Destroy")]
+		public static extern bool VIVEOpenXR_CompositionLayer_Destroy(int layerID);
+		/// <summary>
+		/// destroy composition layer.
+		/// </summary>
+		public bool CompositionLayer_Destroy(int layerID)
+		{
+			return VIVEOpenXR_CompositionLayer_Destroy(layerID);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "submit_CompositionLayerQuad")]
+		public static extern void VIVEOpenXR_Submit_CompositionLayerQuad(XrCompositionLayerQuad quad, LayerType layerType, uint compositionDepth, int layerID);
+		/// <summary>
+		/// submit compostion layer of type quad.
+		/// </summary>
+		public void Submit_CompositionLayerQuad(XrCompositionLayerQuad quad, LayerType layerType, uint compositionDepth, int layerID)
+		{
+			VIVEOpenXR_Submit_CompositionLayerQuad(quad, layerType, compositionDepth, layerID);
+			return;
+		}
+		#endregion
+
+		#region Hook native functions
+		protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+		{
+			DEBUG("CompositionLayer_GetInstanceProcAddr");
+			return CompositionLayer_GetInstanceProcAddr(func);
+		}
+
+		[DllImport(ExtLib, EntryPoint = "compositionlayer_intercept_xrGetInstanceProcAddr")]
+		private static extern IntPtr CompositionLayer_GetInstanceProcAddr(IntPtr func);
+
+		[DllImportAttribute(ExtLib, EntryPoint = "compositionlayer_GetFuncAddrs")]
+		public static extern XrResult VIVEOpenXR_CompositionLayer_GetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr);
+		/// <summary>
+		/// get function address of composition layer.
+		/// </summary>
+		public XrResult CompositionLayer_GetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr)
+		{
+			return VIVEOpenXR_CompositionLayer_GetFuncAddrs(xrInstance, xrGetInstanceProcAddrFuncPtr);
+		}
+
+		#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b06faf09f93c35b4b83640fd9908b630
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerColorScaleBias.cs

@@ -0,0 +1,89 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using AOT;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer (Color Scale Bias)",
+		Desc = "Enable this feature to enable the Composition Layer Color Scale Bias Extension",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenXRColorScaleBiasExtensionString,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		FeatureId = featureId
+	)]
+#endif
+	public class ViveCompositionLayerColorScaleBias : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayer.ColorScaleBias";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer.colorscalebias";
+
+		private const string kOpenXRColorScaleBiasExtensionString = "XR_KHR_composition_layer_color_scale_bias";
+
+		private bool m_ColorScaleBiasExtensionEnabled = true;
+		/// <summary>
+		/// The extension of "XR_KHR_composition_layer_color_scale_bias" is enabled or not.
+		/// </summary>
+		public bool ColorScaleBiasExtensionEnabled
+		{
+			get { return m_ColorScaleBiasExtensionEnabled; }
+		}
+
+
+		#region OpenXR Life Cycle
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled(kOpenXRColorScaleBiasExtensionString))
+			{
+				WARNING("OnInstanceCreate() " + kOpenXRColorScaleBiasExtensionString + " is NOT enabled.");
+
+				m_ColorScaleBiasExtensionEnabled = false;
+				return false;
+			}
+
+			return true;
+		}
+		#endregion
+
+		#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+
+		[DllImportAttribute(ExtLib, EntryPoint = "submit_CompositionLayerColorBias")]
+		public static extern void VIVEOpenXR_Submit_CompositionLayerColorBias(XrCompositionLayerColorScaleBiasKHR colorBias, int layerID);
+		/// <summary>
+		/// Submit Compostion Layer Color Bias Settings to specific layer ID.
+		/// </summary>
+		public void Submit_CompositionLayerColorBias(XrCompositionLayerColorScaleBiasKHR colorBias, int layerID)
+		{
+			if (!ColorScaleBiasExtensionEnabled)
+			{
+				ERROR("Submit_CompositionLayerColorBias: " + kOpenXRColorScaleBiasExtensionString + " is not enabled.");
+				return;
+			}
+
+			VIVEOpenXR_Submit_CompositionLayerColorBias(colorBias, layerID);
+		}
+		#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerColorScaleBias.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a5621f5c5156e7648a0c3a1fa86497a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerCylinder.cs

@@ -0,0 +1,88 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using AOT;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer (Cylinder)",
+		Desc = "Enable this feature to enable the Composition Layer Cylinder Extension",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenXRCylinderExtensionString,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		FeatureId = featureId
+	)]
+#endif
+	public class ViveCompositionLayerCylinder : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayer.Cylinder";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer.cylinder";
+
+		private const string kOpenXRCylinderExtensionString = "XR_KHR_composition_layer_cylinder";
+
+		private bool m_CylinderExtensionEnabled = true;
+		/// <summary>
+		/// The extension "XR_KHR_composition_layer_cylinder" is enabled or not.
+		/// </summary>
+		public bool CylinderExtensionEnabled
+		{
+			get { return m_CylinderExtensionEnabled; }
+		}
+
+
+		#region OpenXR Life Cycle
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled(kOpenXRCylinderExtensionString))
+			{
+				WARNING("OnInstanceCreate() " + kOpenXRCylinderExtensionString + " is NOT enabled.");
+
+				m_CylinderExtensionEnabled = false;
+				return false;
+			}
+
+			return true;
+		}
+		#endregion
+
+		#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+
+		[DllImportAttribute(ExtLib, EntryPoint = "submit_CompositionLayerCylinder")]
+		public static extern void VIVEOpenXR_Submit_CompositionLayerCylinder(XrCompositionLayerCylinderKHR cylinder, LayerType layerType, uint compositionDepth, int layerID);
+		/// <summary>
+		/// submit compostion layer of type cylinder.
+		/// </summary>
+		public void Submit_CompositionLayerCylinder(XrCompositionLayerCylinderKHR cylinder, LayerType layerType, uint compositionDepth, int layerID)
+		{
+			if (!CylinderExtensionEnabled)
+			{
+				ERROR("Submit_CompositionLayerCylinder: " + kOpenXRCylinderExtensionString + " is NOT enabled.");
+			}
+
+			VIVEOpenXR_Submit_CompositionLayerCylinder(cylinder, layerType, compositionDepth, layerID);
+		}
+		#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerCylinder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: abd96d069ecb9b243a69661e0bffdfab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerEquirect.cs

@@ -0,0 +1,120 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using AOT;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer (Equirect)",
+		Desc = "Enable this feature to enable the Composition Layer Equirect Extension",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenXRCylinderExtensionString,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		FeatureId = featureId
+	)]
+#endif
+	public class ViveCompositionLayerEquirect : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayer.Equirect";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer.equirect";
+
+		private const string kOpenXRCylinderExtensionString = "XR_KHR_composition_layer_equirect XR_KHR_composition_layer_equirect2";
+
+		private bool m_EquirectExtensionEnabled = true;
+		/// <summary>
+		/// The extension "XR_KHR_composition_layer_equirect" is enabled or not.
+		/// </summary>
+		public bool EquirectExtensionEnabled
+		{
+			get { return m_EquirectExtensionEnabled; }
+		}
+
+		private bool m_Equirect2ExtensionEnabled = true;
+		/// <summary>
+		/// The extension "XR_KHR_composition_layer_equirect2" is enabled or not.
+		/// </summary>
+		public bool Equirect2ExtensionEnabled
+		{
+			get { return m_Equirect2ExtensionEnabled; }
+		}
+
+
+		#region OpenXR Life Cycle
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled("XR_KHR_composition_layer_equirect"))
+			{
+				WARNING("OnInstanceCreate() " + "XR_KHR_composition_layer_equirect" + " is NOT enabled.");
+
+				m_EquirectExtensionEnabled = false;
+				return false;
+			}
+			
+			if (!OpenXRRuntime.IsExtensionEnabled("XR_KHR_composition_layer_equirect2"))
+			{
+				WARNING("OnInstanceCreate() " + "XR_KHR_composition_layer_equirect2" + " is NOT enabled.");
+
+				m_Equirect2ExtensionEnabled = false;
+				return false;
+			}
+
+			return true;
+		}
+		#endregion
+
+		#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+
+		[DllImportAttribute(ExtLib, EntryPoint = "submit_CompositionLayerEquirect")]
+		public static extern void VIVEOpenXR_Submit_CompositionLayerEquirect(XrCompositionLayerEquirectKHR equirect, LayerType layerType, uint compositionDepth, int layerID);
+		/// <summary>
+		/// submit compostion layer of type equirect.
+		/// </summary>
+		public void Submit_CompositionLayerEquirect(XrCompositionLayerEquirectKHR equirect, LayerType layerType, uint compositionDepth, int layerID)
+		{
+			if (!EquirectExtensionEnabled)
+			{
+				ERROR("Submit_CompositionLayerEquirect: " + "XR_KHR_composition_layer_equirect" + " is NOT enabled.");
+			}
+
+			VIVEOpenXR_Submit_CompositionLayerEquirect(equirect, layerType, compositionDepth, layerID);
+		}
+		
+		[DllImportAttribute(ExtLib, EntryPoint = "submit_CompositionLayerEquirect2")]
+		public static extern void VIVEOpenXR_Submit_CompositionLayerEquirect2(XrCompositionLayerEquirect2KHR equirect2, LayerType layerType, uint compositionDepth, int layerID);
+		/// <summary>
+		/// submit compostion layer of type equirect2.
+		/// </summary>
+		public void Submit_CompositionLayerEquirect2(XrCompositionLayerEquirect2KHR equirect2, LayerType layerType, uint compositionDepth, int layerID)
+		{
+			if (!Equirect2ExtensionEnabled)
+			{
+				ERROR("Submit_CompositionLayerEquirect2: " + "XR_KHR_composition_layer_equirect2" + " is NOT enabled.");
+			}
+
+			VIVEOpenXR_Submit_CompositionLayerEquirect2(equirect2, layerType, compositionDepth, layerID);
+		}
+		#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerEquirect.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec826264ff4d75d4081f2ca472a3e083
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerExtraSettings.cs

@@ -0,0 +1,203 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer (Extra Settings) (Beta)",
+		Desc = "Enable this feature to use the Composition Layer Extra Settings.",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenxrExtensionStrings,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		FeatureId = featureId
+	)]
+#endif
+	public class ViveCompositionLayerExtraSettings : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayer.ExtraSettings";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// Settings Editor Enable Sharpening or Not.
+		/// </summary>
+		public bool SettingsEditorEnableSharpening = false;
+
+		/// <summary>
+		/// Support Sharpening or Not.
+		/// </summary>
+		public bool supportSharpening = false;
+
+		/// <summary>
+		/// Settings Editor Sharpening Mode
+		/// </summary>
+		public XrSharpeningModeHTC SettingsEditorSharpeningMode = XrSharpeningModeHTC.FAST;
+
+		/// <summary>
+		/// Settings Editor Sharpening Levell
+		/// </summary>
+		[Range(0.0f, 1.0f)]
+		public float SettingsEditorSharpeningLevel = 1.0f;
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer.extrasettings";
+
+		/// <summary>
+		/// OpenXR specification.
+		/// </summary>
+		public const string kOpenxrExtensionStrings = "XR_HTC_composition_layer_extra_settings";
+
+		#region OpenXR Life Cycle
+		private bool m_XrInstanceCreated = false;
+		/// <summary>
+		/// The XR instance is created or not.
+		/// </summary>
+		public bool XrInstanceCreated
+		{
+			get { return m_XrInstanceCreated; }
+		}
+		private XrInstance m_XrInstance = 0;
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			foreach (string kOpenxrExtensionString in kOpenxrExtensionStrings.Split(' '))
+			{
+				if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+				{
+					WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+				}
+			}
+
+			m_XrInstanceCreated = true;
+			m_XrInstance = xrInstance;
+			DEBUG("OnInstanceCreate() " + m_XrInstance);
+
+			return true;
+		}
+
+		protected override void OnInstanceDestroy(ulong xrInstance)
+		{
+			m_XrInstanceCreated = false;
+			DEBUG("OnInstanceDestroy() " + m_XrInstance);
+		}
+
+		private XrSystemId m_XrSystemId = 0;
+		protected override void OnSystemChange(ulong xrSystem)
+		{
+			m_XrSystemId = xrSystem;
+			DEBUG("OnSystemChange() " + m_XrSystemId);
+		}
+
+		private bool m_XrSessionCreated = false;
+		/// <summary>
+		/// The XR session is created or not.
+		/// </summary>
+		public bool XrSessionCreated
+		{
+			get { return m_XrSessionCreated; }
+		}
+		private XrSession m_XrSession = 0;
+		protected override void OnSessionCreate(ulong xrSession)
+		{
+			m_XrSession = xrSession;
+			m_XrSessionCreated = true;
+			DEBUG("OnSessionCreate() " + m_XrSession);
+		}
+
+		private bool m_XrSessionEnding = false;
+		/// <summary>
+		/// The XR session is ending or not.
+		/// </summary>
+		public bool XrSessionEnding
+		{
+			get { return m_XrSessionEnding; }
+		}
+
+		protected override void OnSessionBegin(ulong xrSession)
+		{
+			m_XrSessionEnding = false;
+			DEBUG("OnSessionBegin() " + m_XrSession);
+
+			//enable Sharpening 
+			if (OpenXRRuntime.IsExtensionEnabled("XR_HTC_composition_layer_extra_settings"))
+			{
+				ViveCompositionLayer_UpdateSystemProperties(m_XrInstance, m_XrSystemId);
+				supportSharpening = ViveCompositionLayer_IsSupportSharpening();
+				if (supportSharpening && SettingsEditorEnableSharpening)
+				{
+					EnableSharpening(SettingsEditorSharpeningMode, SettingsEditorSharpeningLevel);
+				}
+			}
+		}
+
+		protected override void OnSessionEnd(ulong xrSession)
+		{
+			m_XrSessionEnding = true;
+			DEBUG("OnSessionEnd() " + m_XrSession);
+		}
+
+		protected override void OnSessionDestroy(ulong xrSession)
+		{
+			m_XrSessionCreated = false;
+			DEBUG("OnSessionDestroy() " + xrSession);
+		}
+
+		#endregion
+
+		#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+
+		[DllImportAttribute(ExtLib, EntryPoint = "viveCompositionLayer_UpdateSystemProperties")]
+		private static extern int VIVEOpenXR_ViveCompositionLayer_UpdateSystemProperties(XrInstance instance, XrSystemId system_id);
+		private int ViveCompositionLayer_UpdateSystemProperties(XrInstance instance, XrSystemId system_id)
+		{
+			return VIVEOpenXR_ViveCompositionLayer_UpdateSystemProperties(instance, system_id);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "viveCompositionLayer_IsSupportSharpening")]
+		private static extern bool VIVEOpenXR_ViveCompositionLayer_IsSupportSharpening();
+		private bool ViveCompositionLayer_IsSupportSharpening()
+		{
+			return VIVEOpenXR_ViveCompositionLayer_IsSupportSharpening();
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "viveCompositionLayer_enableSharpening")]
+		private static extern int VIVEOpenXR_ViveCompositionLayer_enableSharpening(XrSharpeningModeHTC sharpeningMode, float sharpeningLevel);
+		/// <summary>
+		/// Enable the sharpening setting applying to the projection layer.
+		/// </summary>
+		/// <param name="sharpeningMode">The sharpening mode in <see cref="XrSharpeningModeHTC"/>.</param>
+		/// <param name="sharpeningLevel">The sharpening level in float [0, 1].</param>
+		/// <returns>True for success.</returns>
+		public bool EnableSharpening(XrSharpeningModeHTC sharpeningMode, float sharpeningLevel)
+		{
+			return (VIVEOpenXR_ViveCompositionLayer_enableSharpening(sharpeningMode, sharpeningLevel) == 0);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "viveCompositionLayer_disableSharpening")]
+		private static extern int VIVEOpenXR_ViveCompositionLayer_DisableSharpening();
+		/// <summary>
+		/// Disable the sharpening setting on the projection layer.
+		/// </summary>
+		/// <returns>True for success</returns>
+		public bool DisableSharpening()
+		{
+			return (VIVEOpenXR_ViveCompositionLayer_DisableSharpening() == 0);
+		}
+		#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerExtraSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f26de592e4135874baf6e64cc94183be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerHelper.cs

@@ -0,0 +1,583 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace VIVE.OpenXR.CompositionLayer
+{
+	public struct XrSwapchain : IEquatable<ulong>
+	{
+		private readonly ulong value;
+
+		public XrSwapchain(ulong u)
+		{
+			value = u;
+		}
+
+		public static implicit operator ulong(XrSwapchain xrBool)
+		{
+			return xrBool.value;
+		}
+		public static implicit operator XrSwapchain(ulong u)
+		{
+			return new XrSwapchain(u);
+		}
+
+		public bool Equals(XrSwapchain other)
+		{
+			return value == other.value;
+		}
+		public bool Equals(ulong other)
+		{
+			return value == other;
+		}
+		public override bool Equals(object obj)
+		{
+			return obj is XrSwapchain && Equals((XrSwapchain)obj);
+		}
+
+		public override int GetHashCode()
+		{
+			return value.GetHashCode();
+		}
+
+		public override string ToString()
+		{
+			return value.ToString();
+		}
+
+		public static bool operator ==(XrSwapchain a, XrSwapchain b) { return a.Equals(b); }
+		public static bool operator !=(XrSwapchain a, XrSwapchain b) { return !a.Equals(b); }
+		public static bool operator >=(XrSwapchain a, XrSwapchain b) { return a.value >= b.value; }
+		public static bool operator <=(XrSwapchain a, XrSwapchain b) { return a.value <= b.value; }
+		public static bool operator >(XrSwapchain a, XrSwapchain b) { return a.value > b.value; }
+		public static bool operator <(XrSwapchain a, XrSwapchain b) { return a.value < b.value; }
+		public static XrSwapchain operator +(XrSwapchain a, XrSwapchain b) { return a.value + b.value; }
+		public static XrSwapchain operator -(XrSwapchain a, XrSwapchain b) { return a.value - b.value; }
+		public static XrSwapchain operator *(XrSwapchain a, XrSwapchain b) { return a.value * b.value; }
+		public static XrSwapchain operator /(XrSwapchain a, XrSwapchain b)
+		{
+			if (b.value == 0)
+			{
+				throw new DivideByZeroException();
+			}
+			return a.value / b.value;
+		}
+
+	}
+
+	public struct XrSwapchainCreateFlags : IEquatable<UInt64>
+	{
+		private readonly UInt64 value;
+
+		public XrSwapchainCreateFlags(UInt64 u)
+		{
+			value = u;
+		}
+
+		public static implicit operator UInt64(XrSwapchainCreateFlags xrBool)
+		{
+			return xrBool.value;
+		}
+		public static implicit operator XrSwapchainCreateFlags(UInt64 u)
+		{
+			return new XrSwapchainCreateFlags(u);
+		}
+
+		public bool Equals(XrSwapchainCreateFlags other)
+		{
+			return value == other.value;
+		}
+		public bool Equals(UInt64 other)
+		{
+			return value == other;
+		}
+		public override bool Equals(object obj)
+		{
+			return obj is XrSwapchainCreateFlags && Equals((XrSwapchainCreateFlags)obj);
+		}
+
+		public override int GetHashCode()
+		{
+			return value.GetHashCode();
+		}
+
+		public override string ToString()
+		{
+			return value.ToString();
+		}
+
+		public static bool operator ==(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.Equals(b); }
+		public static bool operator !=(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return !a.Equals(b); }
+		public static bool operator >=(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value >= b.value; }
+		public static bool operator <=(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value <= b.value; }
+		public static bool operator >(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value > b.value; }
+		public static bool operator <(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value < b.value; }
+		public static XrSwapchainCreateFlags operator +(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value + b.value; }
+		public static XrSwapchainCreateFlags operator -(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value - b.value; }
+		public static XrSwapchainCreateFlags operator *(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b) { return a.value * b.value; }
+		public static XrSwapchainCreateFlags operator /(XrSwapchainCreateFlags a, XrSwapchainCreateFlags b)
+		{
+			if (b.value == 0)
+			{
+				throw new DivideByZeroException();
+			}
+			return a.value / b.value;
+		}
+	}
+
+	public struct XrSwapchainUsageFlags : IEquatable<UInt64>
+	{
+		private readonly UInt64 value;
+
+		public XrSwapchainUsageFlags(UInt64 u)
+		{
+			value = u;
+		}
+
+		public static implicit operator UInt64(XrSwapchainUsageFlags xrBool)
+		{
+			return xrBool.value;
+		}
+		public static implicit operator XrSwapchainUsageFlags(UInt64 u)
+		{
+			return new XrSwapchainUsageFlags(u);
+		}
+
+		public bool Equals(XrSwapchainUsageFlags other)
+		{
+			return value == other.value;
+		}
+		public bool Equals(UInt64 other)
+		{
+			return value == other;
+		}
+		public override bool Equals(object obj)
+		{
+			return obj is XrSwapchainUsageFlags && Equals((XrSwapchainUsageFlags)obj);
+		}
+
+		public override int GetHashCode()
+		{
+			return value.GetHashCode();
+		}
+
+		public override string ToString()
+		{
+			return value.ToString();
+		}
+
+		public static bool operator ==(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.Equals(b); }
+		public static bool operator !=(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return !a.Equals(b); }
+		public static bool operator >=(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value >= b.value; }
+		public static bool operator <=(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value <= b.value; }
+		public static bool operator >(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value > b.value; }
+		public static bool operator <(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value < b.value; }
+		public static XrSwapchainUsageFlags operator +(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value + b.value; }
+		public static XrSwapchainUsageFlags operator -(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value - b.value; }
+		public static XrSwapchainUsageFlags operator *(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b) { return a.value * b.value; }
+		public static XrSwapchainUsageFlags operator /(XrSwapchainUsageFlags a, XrSwapchainUsageFlags b)
+		{
+			if (b.value == 0)
+			{
+				throw new DivideByZeroException();
+			}
+			return a.value / b.value;
+		}
+	}
+
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerQuad
+	{
+		public XrStructureType type;
+		public IntPtr next;
+		public XrCompositionLayerFlags layerFlags;
+		public XrSpace space;
+		public XrEyeVisibility eyeVisibility;
+		public XrSwapchainSubImage subImage;
+		public XrPosef pose;
+		public XrExtent2Df size;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerCylinderKHR
+	{
+		public XrStructureType type;
+		public IntPtr next;
+		public XrCompositionLayerFlags layerFlags;
+		public XrSpace space;
+		public XrEyeVisibility eyeVisibility;
+		public XrSwapchainSubImage subImage;
+		public XrPosef pose;
+		public float radius;
+		public float centralAngle;
+		public float aspectRatio;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerEquirectKHR
+	{
+		public XrStructureType type;
+		public IntPtr next;
+		public XrCompositionLayerFlags layerFlags;
+		public XrSpace space;
+		public XrEyeVisibility eyeVisibility;
+		public XrSwapchainSubImage subImage;
+		public XrPosef pose;
+		public float radius;
+		public XrVector2f scale;
+		public XrVector2f bias;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerEquirect2KHR
+	{
+		public XrStructureType type;
+		public IntPtr next;
+		public XrCompositionLayerFlags layerFlags;
+		public XrSpace space;
+		public XrEyeVisibility eyeVisibility;
+		public XrSwapchainSubImage subImage;
+		public XrPosef pose;
+		public float radius;
+		public float centralHorizontalAngle;
+		public float upperVerticalAngle;
+		public float lowerVerticalAngle;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrSwapchainSubImage
+	{
+		public XrSwapchain swapchain;
+		public XrRect2Di imageRect;
+		public uint imageArrayIndex;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerColorScaleBiasKHR
+	{
+		public XrStructureType type;
+		public IntPtr next;
+		public XrColor4f colorScale;
+		public XrColor4f colorBias;
+	}
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerSharpeningSettingHTC
+	{
+        public XrStructureType type;
+        public IntPtr next;
+        public XrSharpeningModeHTC mode;
+        public float sharpeningLevel;
+    }
+	[StructLayout(LayoutKind.Sequential)]
+    public struct XrCompositionLayerSuperSamplingSettingHTC
+	{
+        public XrStructureType type;
+        public IntPtr next;
+        public XrSuperSamplingModeHTC mode;
+    }
+	public enum XrSharpeningModeHTC
+	{
+        FAST = 0,
+        NORMAL = 1,
+        QUALITY = 2,
+        AUTOMATIC = 3,
+	}
+	public enum XrSuperSamplingModeHTC
+	{
+        FAST = 0,
+        NORMAL = 1,
+        QUALITY = 2,
+        AUTOMATIC = 3,
+    }
+
+	public enum GraphicsAPI
+	{
+		GLES3	= 1,
+		Vulkan	= 2
+	}
+	public enum LayerType
+	{
+		///<summary> Overlays are composition layers rendered after the projection layer </summary>
+		Overlay = 1,
+		///<summary> Underlays are composition layers rendered before the projection layer </summary>
+		Underlay = 2
+	}
+
+	/// <summary>
+	/// An application can create an <see cref="XrPassthroughHTC">XrPassthroughHTC</see> handle by calling <see cref="ViveCompositionLayerHelper.xrCreatePassthroughHTC">xrCreatePassthroughHTC</see>. The returned passthrough handle can be subsequently used in API calls.
+	/// </summary>
+	public struct XrPassthroughHTC : IEquatable<UInt64>
+	{
+		private readonly UInt64 value;
+
+		public XrPassthroughHTC(UInt64 u)
+		{
+			value = u;
+		}
+
+		public static implicit operator UInt64(XrPassthroughHTC equatable)
+		{
+			return equatable.value;
+		}
+		public static implicit operator XrPassthroughHTC(UInt64 u)
+		{
+			return new XrPassthroughHTC(u);
+		}
+
+		public bool Equals(XrPassthroughHTC other)
+		{
+			return value == other.value;
+		}
+		public bool Equals(UInt64 other)
+		{
+			return value == other;
+		}
+		public override bool Equals(object obj)
+		{
+			return obj is XrPassthroughHTC && Equals((XrPassthroughHTC)obj);
+		}
+
+		public override int GetHashCode()
+		{
+			return value.GetHashCode();
+		}
+
+		public override string ToString()
+		{
+			return value.ToString();
+		}
+
+		public static bool operator ==(XrPassthroughHTC a, XrPassthroughHTC b) { return a.Equals(b); }
+		public static bool operator !=(XrPassthroughHTC a, XrPassthroughHTC b) { return !a.Equals(b); }
+		public static bool operator >=(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value >= b.value; }
+		public static bool operator <=(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value <= b.value; }
+		public static bool operator >(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value > b.value; }
+		public static bool operator <(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value < b.value; }
+		public static XrPassthroughHTC operator +(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value + b.value; }
+		public static XrPassthroughHTC operator -(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value - b.value; }
+		public static XrPassthroughHTC operator *(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value * b.value; }
+		public static XrPassthroughHTC operator /(XrPassthroughHTC a, XrPassthroughHTC b)
+		{
+			if (b.value == 0)
+			{
+				throw new DivideByZeroException();
+			}
+			return a.value / b.value;
+		}
+
+	}
+
+	/// <summary>
+	/// The XrPassthroughFormHTC enumeration identifies the form of the passthrough, presenting the passthrough fill the full screen or project onto a specified mesh.
+	/// </summary>
+	public enum XrPassthroughFormHTC
+	{
+		/// <summary>
+		/// Presents the passthrough with full of the entire screen..
+		/// </summary>
+		XR_PASSTHROUGH_FORM_PLANAR_HTC = 0,
+		/// <summary>
+		/// Presents the passthrough projecting onto a custom mesh.
+		/// </summary>
+		XR_PASSTHROUGH_FORM_PROJECTED_HTC = 1,
+	};
+
+	/// <summary>
+	/// The XrPassthroughCreateInfoHTC structure describes the information to create an <see cref="XrPassthroughCreateInfoHTC">XrPassthroughCreateInfoHTC</see> handle.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrPassthroughCreateInfoHTC
+	{
+		/// <summary>
+		/// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// The form specifies the form of passthrough.
+		/// </summary>
+		public XrPassthroughFormHTC form;
+
+		/// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+		/// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+		/// <param name="in_facialTrackingType">An XrFacialTrackingTypeHTC which describes which type of facial tracking should be used for this handle.</param>
+		public XrPassthroughCreateInfoHTC(XrStructureType in_type, IntPtr in_next, XrPassthroughFormHTC in_form)
+		{
+			type = in_type;
+			next = in_next;
+			form = in_form;
+		}
+	};
+	/// <summary>
+	/// The application can specify the XrPassthroughColorHTC to adjust the alpha value of the passthrough. The range is between 0.0f and 1.0f, 1.0f means opaque.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrPassthroughColorHTC
+	{
+		/// <summary>
+		/// The XrStructureType of this structure.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// Next is NULL or a pointer to the next structure in a structure chain, such as XrPassthroughMeshTransformInfoHTC.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// The alpha value of the passthrough in the range [0, 1].
+		/// </summary>
+		public float alpha;
+		public XrPassthroughColorHTC(XrStructureType in_type, IntPtr in_next, float in_alpha)
+        {
+			type = in_type;
+			next = in_next;
+			alpha = in_alpha;
+		}
+	};
+	/// <summary>
+	/// A pointer to XrCompositionLayerPassthroughHTC may be submitted in xrEndFrame as a pointer to the base structure XrCompositionLayerBaseHeader, in the desired layer order, to request the runtime to composite a passthrough layer into the final frame output.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrCompositionLayerPassthroughHTC
+	{
+		/// <summary>
+		/// The XrStructureType of this structure.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// Next is NULL or a pointer to the next structure in a structure chain, such as XrPassthroughMeshTransformInfoHTC.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// A bitmask of XrCompositionLayerFlagBits describing flags to apply to the layer.
+		/// </summary>
+		public XrCompositionLayerFlags layerFlags;
+		/// <summary>
+		/// The XrSpace that specifies the layer’s space - must be XR_NULL_HANDLE.
+		/// </summary>
+		public XrSpace space;
+		/// <summary>
+		/// The XrPassthroughHTC previously created by xrCreatePassthroughHTC.
+		/// </summary>
+		public XrPassthroughHTC passthrough;
+		/// <summary>
+		/// The XrPassthroughColorHTC describing the color information with the alpha value of the passthrough layer.
+		/// </summary>
+		public XrPassthroughColorHTC color;
+		public XrCompositionLayerPassthroughHTC(XrStructureType in_type, IntPtr in_next, XrCompositionLayerFlags in_layerFlags,
+			XrSpace in_space, XrPassthroughHTC in_passthrough, XrPassthroughColorHTC in_color)
+		{
+			type = in_type;
+			next = in_next;
+			layerFlags = in_layerFlags;
+			space = in_space;
+			passthrough = in_passthrough;
+			color = in_color;
+		}
+	};
+
+	/// <summary>
+	/// The XrPassthroughMeshTransformInfoHTC structure describes the mesh and transformation.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrPassthroughMeshTransformInfoHTC
+	{
+		/// <summary>
+		/// The XrStructureType of this structure.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// Next is NULL or a pointer to the next structure in a structure chain.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// The count of vertices array in the mesh.
+		/// </summary>
+		public UInt32 vertexCount;
+		/// <summary>
+		/// An array of XrVector3f. The size of the array must be equal to vertexCount.
+		/// </summary>
+		public XrVector3f[] vertices;
+		/// <summary>
+		/// The count of indices array in the mesh.
+		/// </summary>
+		public UInt32 indexCount;
+		/// <summary>
+		/// An array of triangle indices. The size of the array must be equal to indexCount.
+		/// </summary>
+		public UInt32[] indices;
+		/// <summary>
+		/// The XrSpace that defines the projected passthrough's base space for transformations.
+		/// </summary>
+		public XrSpace baseSpace;
+		/// <summary>
+		/// The XrTime that defines the time at which the transform is applied.
+		/// </summary>
+		public XrTime time;
+		/// <summary>
+		/// The XrPosef that defines the pose of the mesh
+		/// </summary>
+		public XrPosef pose;
+		/// <summary>
+		/// The XrVector3f that defines the scale of the mesh
+		/// </summary>
+		public XrVector3f scale;
+		public XrPassthroughMeshTransformInfoHTC(XrStructureType in_type, IntPtr in_next, UInt32 in_vertexCount,
+			XrVector3f[] in_vertices, UInt32 in_indexCount, UInt32[] in_indices, XrSpace in_baseSpace, XrTime in_time,
+			XrPosef in_pose, XrVector3f in_scale)
+		{
+			type = in_type;
+			next = in_next;
+			vertexCount = in_vertexCount;
+			vertices = in_vertices;
+			indexCount = in_indexCount;
+			indices = in_indices;
+			baseSpace = in_baseSpace;
+			time = in_time;
+			pose = in_pose;
+			scale = in_scale;
+		}
+	};
+
+	public static class ViveCompositionLayerHelper
+	{
+		/// <summary>
+		/// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreatePassthroughHTC">xrCreatePassthroughHTC</see>.
+		/// </summary>
+		/// <param name="session">An <see cref="XrSession">XrSession</see>  in which the passthrough will be active.</param>
+		/// <param name="createInfo">createInfo is a pointer to an <see cref="XrPassthroughCreateInfoHTC">XrPassthroughCreateInfoHTC</see> structure containing information about how to create the passthrough.</param>
+		/// <param name="passthrough">passthrough is a pointer to a handle in which the created <see cref="XrPassthroughHTC">XrPassthroughHTC</see> is returned.</param>
+		/// <returns>XR_SUCCESS for success.</returns>
+		public delegate XrResult xrCreatePassthroughHTCDelegate(
+			XrSession session,
+			XrPassthroughCreateInfoHTC createInfo,
+			out XrPassthroughHTC passthrough);
+
+		/// <summary>
+		/// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyPassthroughHTC">xrDestroyFacialTrackerHTC</see>.
+		/// </summary>
+		/// <param name="passthrough">passthrough is the <see cref="XrPassthroughHTC">XrPassthroughHTC</see> to be destroyed..</param>
+		/// <returns>XR_SUCCESS for success.</returns>
+		public delegate XrResult xrDestroyPassthroughHTCDelegate(
+			XrPassthroughHTC passthrough);
+		// Flag bits for XrCompositionLayerFlags
+		public static XrCompositionLayerFlags XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT = 0x00000001;
+		public static XrCompositionLayerFlags XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT = 0x00000002;
+		public static XrCompositionLayerFlags XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT = 0x00000004;
+
+		// Flag bits for XrSwapchainCreateFlags
+		public static XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT = 0x00000001;
+		public static XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT = 0x00000002;
+
+		// Flag bits for XrSwapchainUsageFlags
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT = 0x00000001;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000002;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT = 0x00000004;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT = 0x00000008;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT = 0x00000010;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_SAMPLED_BIT = 0x00000020;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT = 0x00000040;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND = 0x00000080;
+		public static XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR = 0x00000080;
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7dfb147f98026e44786fda53bb2aeb18
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerPassthrough.cs

@@ -0,0 +1,943 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using AOT;
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using System.Linq;
+using UnityEngine.XR;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.CompositionLayer.Passthrough
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Composition Layer (Passthrough) (Deprecated)",
+		Desc = "Enable this feature to use the HTC Passthrough feature.",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenxrExtensionStrings,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android ,BuildTargetGroup.Standalone},
+		FeatureId = featureId
+	)]
+#endif
+	[Obsolete("This class is deprecated. Please use VivePassthrough instead.")]
+	public class ViveCompositionLayerPassthrough : OpenXRFeature
+	{
+		const string LOG_TAG = "VIVE.OpenXR.ViveCompositionLayerPassthrough";
+		static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		private List<int> passthroughIDList = new List<int>();
+		/// <summary>
+		/// The List of passthrough ID.
+		/// </summary>
+		public List<int> PassthroughIDList { get{ return new List<int>(passthroughIDList); } }
+
+		private List<XRInputSubsystem> inputSubsystems = new List<XRInputSubsystem>();
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.compositionlayer.passthrough";
+
+		/// <summary>
+		/// The extension string.
+		/// </summary>
+		public const string kOpenxrExtensionStrings = "XR_HTC_passthrough";
+
+		private bool m_HTCPassthroughExtensionEnabled = true;
+		/// <summary>
+		/// The HTC Passthrough extension is enabled or not.
+		/// </summary>
+		public bool HTCPassthroughExtensionEnabled
+		{
+			get { return m_HTCPassthroughExtensionEnabled; }
+		}
+
+		#region OpenXR Life Cycle
+		private bool m_XrInstanceCreated = false;
+		/// <summary>
+		/// The XR instance is created or not.
+		/// </summary>
+		public bool XrInstanceCreated
+		{
+			get { return m_XrInstanceCreated; }
+		}
+#if UNITY_STANDALONE
+		private static IntPtr xrGetInstanceProcAddr_prev;
+		private static IntPtr XrEndFrame_prev;
+		private static IntPtr XrWaitFrame_prev;
+		private static List<IntPtr> layerListOrigin = new List<IntPtr>();
+		private static List<IntPtr> layerListModified = new List<IntPtr>();
+		private static IntPtr layersModified = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(IntPtr)) * 30)); //Preallocate a layer buffer with sufficient size and reuse it for each frame.
+		protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+		{
+			UnityEngine.Debug.Log("EXT: registering our own xrGetInstanceProcAddr");
+			xrGetInstanceProcAddr_prev = func;
+			return Marshal.GetFunctionPointerForDelegate(Intercept_xrGetInstanceProcAddr);
+		}
+		[MonoPInvokeCallback(typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate))]
+		private static XrResult InterceptXrEndFrame_xrGetInstanceProcAddr(XrInstance instance, string name, out IntPtr function)
+		{
+			if (xrGetInstanceProcAddr_prev == null || xrGetInstanceProcAddr_prev == IntPtr.Zero)
+			{
+				UnityEngine.Debug.LogError("xrGetInstanceProcAddr_prev is null");
+				function = IntPtr.Zero;
+				return XrResult.XR_ERROR_VALIDATION_FAILURE;
+			}
+
+			// Get delegate of old xrGetInstanceProcAddr.
+			var xrGetProc = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrGetInstanceProcAddrDelegate>(xrGetInstanceProcAddr_prev);
+			XrResult result = xrGetProc(instance, name, out function);
+			if (name == "xrEndFrame")
+			{
+				XrEndFrame_prev = function;
+				m_intercept_xrEndFrame = intercepted_xrEndFrame;
+				function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrEndFrame); ;
+				UnityEngine.Debug.Log("Getting xrEndFrame func");
+			}
+			if (name == "xrWaitFrame")
+			{
+				XrWaitFrame_prev = function;
+				m_intercept_xrWaitFrame = intercepted_xrWaitFrame;
+				function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame); ;
+				UnityEngine.Debug.Log("Getting xrWaitFrame func");
+			}
+			return result;
+		}
+
+		[MonoPInvokeCallback(typeof(OpenXRHelper.xrEndFrameDelegate))]
+		private static XrResult intercepted_xrEndFrame(XrSession session, ref XrFrameEndInfo frameEndInfo)
+		{
+			XrResult res;
+			// Get delegate of prev xrEndFrame.
+			var xrEndFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrEndFrameDelegate>(XrEndFrame_prev);
+
+			layerListOrigin.Clear();
+			uint layerCount = frameEndInfo.layerCount;
+			IntPtr layers = frameEndInfo.layers;
+			for (int i = 0; i < layerCount; i++)
+			{
+				IntPtr ptr = Marshal.ReadIntPtr(layers, i * Marshal.SizeOf(typeof(IntPtr)));
+				XrCompositionLayerBaseHeader header = (XrCompositionLayerBaseHeader)Marshal.PtrToStructure(ptr, typeof(XrCompositionLayerBaseHeader));
+				layerListOrigin.Add(ptr);
+			}
+			List<IntPtr> layerListNew;
+			if (layerListModified.Count != 0)
+			{
+				layerListNew = new List<IntPtr>(layerListModified);
+			}
+			else
+			{
+				layerListNew = new List<IntPtr>(layerListOrigin);
+			}
+			for (int i = 0; i < layerListNew.Count; i++)
+			{
+				Marshal.WriteIntPtr(layersModified, i * Marshal.SizeOf(typeof(IntPtr)), layerListNew[i]);
+			}
+			frameEndInfo.layers = layersModified;
+			frameEndInfo.layerCount = (uint)layerListNew.Count;
+
+			res = xrEndFrame(session, ref frameEndInfo);
+			return res;
+		}
+		private static XrFrameWaitInfo m_frameWaitInfo;
+		private static XrFrameState m_frameState;
+		[MonoPInvokeCallback(typeof(OpenXRHelper.xrWaitFrameDelegate))]
+		private static int intercepted_xrWaitFrame(ulong session, ref XrFrameWaitInfo frameWaitInfo, ref XrFrameState frameState)
+		{
+			var xrWaitFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrWaitFrameDelegate>(XrWaitFrame_prev);
+			int res = xrWaitFrame(session, ref frameWaitInfo, ref frameState);
+			m_frameWaitInfo = frameWaitInfo;
+			m_frameState = frameState;
+			return res;
+		}
+		public void GetOriginEndFrameLayerList(out List<IntPtr> layers)
+		{
+			layers = new List<IntPtr>(layerListOrigin);
+		}
+
+		public void SubmitLayers(List<IntPtr> layers)
+		{
+			layerListModified = new List<IntPtr>(layers);
+			//UnityEngine.Debug.Log("####Update submit end " + layerListModified.Count);
+		}
+		public XrFrameState GetFrameState()
+		{
+			return m_frameState;
+		}
+#endif
+
+		private XrInstance m_XrInstance = 0;
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			foreach (string kOpenxrExtensionString in kOpenxrExtensionStrings.Split(' '))
+			{
+				if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+				{
+					WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+
+					m_HTCPassthroughExtensionEnabled = false;
+					return false;
+				}
+			}
+
+			m_XrInstanceCreated = true;
+			m_XrInstance = xrInstance;
+			DEBUG("OnInstanceCreate() " + m_XrInstance);
+
+			return GetXrFunctionDelegates(m_XrInstance);
+		}
+
+		protected override void OnInstanceDestroy(ulong xrInstance)
+		{
+			m_XrInstanceCreated = false;
+			DEBUG("OnInstanceDestroy() " + m_XrInstance);
+		}
+
+		private XrSystemId m_XrSystemId = 0;
+		protected override void OnSystemChange(ulong xrSystem)
+		{
+			m_XrSystemId = xrSystem;
+			DEBUG("OnSystemChange() " + m_XrSystemId);
+		}
+
+		private bool m_XrSessionCreated = false;
+		/// <summary>
+		/// The XR session is created or not.
+		/// </summary>
+		public bool XrSessionCreated
+		{
+			get { return m_XrSessionCreated; }
+		}
+		private XrSession m_XrSession = 0;
+		protected override void OnSessionCreate(ulong xrSession)
+		{
+			m_XrSession = xrSession;
+			m_XrSessionCreated = true;
+			DEBUG("OnSessionCreate() " + m_XrSession);
+		}
+
+		private bool m_XrSessionEnding = false;
+		/// <summary>
+		/// The XR session is ending or not.
+		/// </summary>
+		public bool XrSessionEnding
+		{
+			get { return m_XrSessionEnding; }
+		}
+
+		private XrSpace m_WorldLockSpaceOriginOnHead = 0, m_WorldLockSpaceOriginOnFloor = 0, m_HeadLockSpace = 0;
+		private XrSpace WorldLockSpaceOriginOnHead
+		{
+			get { return m_WorldLockSpaceOriginOnHead; }
+		}
+		private XrSpace WorldLockSpaceOriginOnFloor
+		{
+			get { return m_WorldLockSpaceOriginOnFloor; }
+		}
+		private XrSpace HeadLockSpace
+		{
+			get { return m_HeadLockSpace; }
+		}
+
+		protected override void OnSessionBegin(ulong xrSession)
+		{
+			m_XrSessionEnding = false;
+			DEBUG("OnSessionBegin() " + m_XrSession);
+
+			// Enumerate supported reference space types and create the XrSpace.
+			XrReferenceSpaceType[] spaces = new XrReferenceSpaceType[Enum.GetNames(typeof(XrReferenceSpaceType)).Count()];
+			UInt32 spaceCountOutput;
+			if (EnumerateReferenceSpaces(
+				spaceCapacityInput: 0,
+				spaceCountOutput: out spaceCountOutput,
+				spaces: out spaces[0]) == XrResult.XR_SUCCESS)
+			{
+				//DEBUG("spaceCountOutput: " + spaceCountOutput);
+
+				Array.Resize(ref spaces, (int)spaceCountOutput);
+				if (EnumerateReferenceSpaces(
+					spaceCapacityInput: spaceCountOutput,
+					spaceCountOutput: out spaceCountOutput,
+					spaces: out spaces[0]) == XrResult.XR_SUCCESS)
+				{
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
+						referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL;
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoWorldLock,
+						space: out m_WorldLockSpaceOriginOnHead) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnHead);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for world lock layers on head failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for world lock on head layers.");
+					}
+
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
+						referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE;
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoWorldLock,
+						space: out m_WorldLockSpaceOriginOnFloor) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnFloor);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for world lock layers on floor failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for world lock on floor layers.");
+					}
+
+					if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW))
+					{
+						XrReferenceSpaceCreateInfo referenceSpaceCreateInfoHeadLock;
+						referenceSpaceCreateInfoHeadLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
+						referenceSpaceCreateInfoHeadLock.next = IntPtr.Zero;
+						referenceSpaceCreateInfoHeadLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW;
+						referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
+						referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
+
+						if (CreateReferenceSpace(
+						createInfo: ref referenceSpaceCreateInfoHeadLock,
+						space: out m_HeadLockSpace) == XrResult.XR_SUCCESS)
+						{
+							//DEBUG("CreateReferenceSpace: " + m_HeadLockSpace);
+						}
+						else
+						{
+							ERROR("CreateReferenceSpace for head lock layers failed.");
+						}
+					}
+					else
+					{
+						ERROR("CreateReferenceSpace no space type for head lock layers.");
+					}
+				}
+				else
+				{
+					ERROR("EnumerateReferenceSpaces(" + spaceCountOutput + ") failed.");
+				}
+			}
+			else
+			{
+				ERROR("EnumerateReferenceSpaces(0) failed.");
+			}
+		}
+
+		protected override void OnSessionEnd(ulong xrSession)
+		{
+			m_XrSessionEnding = true;
+			DEBUG("OnSessionEnd() " + m_XrSession);
+		}
+
+		/// <summary>
+		/// The delegate of Passthrough Session Destroy.
+		/// </summary>
+		public delegate void OnPassthroughSessionDestroyDelegate(int passthroughID);
+		private Dictionary<int, OnPassthroughSessionDestroyDelegate> OnPassthroughSessionDestroyHandlerDictionary = new Dictionary<int, OnPassthroughSessionDestroyDelegate>();
+		protected override void OnSessionDestroy(ulong xrSession)
+		{
+			m_XrSessionCreated = false;
+			DEBUG("OnSessionDestroy() " + xrSession);
+#if UNITY_ANDROID
+			//Notify that all passthrough layers should be destroyed
+			List<int> currentPassthroughIDs = PassthroughIDList;
+			foreach (int passthroughID in currentPassthroughIDs)
+			{
+				OnPassthroughSessionDestroyDelegate OnPassthroughSessionDestroyHandler = OnPassthroughSessionDestroyHandlerDictionary[passthroughID];
+
+				OnPassthroughSessionDestroyHandler?.Invoke(passthroughID);
+			}
+#endif
+#if UNITY_STANDALONE
+			//Notify that all passthrough layers should be destroyed
+			List<XrPassthroughHTC> currentPassthroughs = PassthroughList;
+			foreach (XrPassthroughHTC passthrough in currentPassthroughs)
+			{
+				DestroyPassthroughHTC(passthrough);
+			}
+#endif
+			if (m_HeadLockSpace != 0)
+			{
+				DestroySpace(m_HeadLockSpace);
+				m_HeadLockSpace = 0;
+			}
+			if (m_WorldLockSpaceOriginOnFloor != 0)
+			{
+				DestroySpace(m_WorldLockSpaceOriginOnFloor);
+				m_WorldLockSpaceOriginOnFloor = 0;
+			}
+			if (m_WorldLockSpaceOriginOnHead != 0)
+			{
+				DestroySpace(m_WorldLockSpaceOriginOnHead);
+				m_WorldLockSpaceOriginOnHead = 0;
+			}
+		}
+
+		/// <summary>
+		/// The current XR session state.
+		/// </summary>
+		public XrSessionState XrSessionCurrentState
+		{
+			get { return m_XrSessionNewState; }
+		}
+		private XrSessionState m_XrSessionNewState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
+		private XrSessionState m_XrSessionOldState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
+		protected override void OnSessionStateChange(int oldState, int newState)
+		{
+			DEBUG("OnSessionStateChange() oldState: " + oldState + " newState:" + newState);
+
+			if (Enum.IsDefined(typeof(XrSessionState), oldState))
+			{
+				m_XrSessionOldState = (XrSessionState)oldState;
+			}
+			else
+			{
+				DEBUG("OnSessionStateChange() oldState undefined");
+			}
+
+			if (Enum.IsDefined(typeof(XrSessionState), newState)) 
+			{
+				m_XrSessionNewState = (XrSessionState)newState;
+			}
+			else
+			{
+				DEBUG("OnSessionStateChange() newState undefined");
+			}
+			
+		}
+#endregion
+
+#region OpenXR function delegates
+		/// xrGetInstanceProcAddr
+		OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+#if UNITY_STANDALONE
+		OpenXRHelper.xrGetInstanceProcAddrDelegate Intercept_xrGetInstanceProcAddr =
+			new OpenXRHelper.xrGetInstanceProcAddrDelegate(InterceptXrEndFrame_xrGetInstanceProcAddr);
+#endif
+		private static OpenXRHelper.xrEndFrameDelegate m_intercept_xrEndFrame;
+		private static OpenXRHelper.xrWaitFrameDelegate m_intercept_xrWaitFrame;
+		/// xrGetSystemProperties
+		OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
+		/// <summary>
+		/// Helper function to get this feature' properties.
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>
+		/// </summary>
+		public XrResult GetSystemProperties(ref XrSystemProperties properties)
+		{
+			if (m_XrInstanceCreated)
+			{
+				return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
+			}
+
+			return XrResult.XR_ERROR_INSTANCE_LOST;
+		}
+
+		/// xrEnumerateReferenceSpaces
+		OpenXRHelper.xrEnumerateReferenceSpacesDelegate xrEnumerateReferenceSpaces;
+		public XrResult EnumerateReferenceSpaces(UInt32 spaceCapacityInput, out UInt32 spaceCountOutput, out XrReferenceSpaceType spaces)
+		{
+			if (!m_XrSessionCreated)
+			{
+				spaceCountOutput = 0;
+				spaces = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT;
+				return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
+			}
+
+			return xrEnumerateReferenceSpaces(m_XrSession, spaceCapacityInput, out spaceCountOutput, out spaces);
+		}
+
+		/// xrCreateReferenceSpace
+		OpenXRHelper.xrCreateReferenceSpaceDelegate xrCreateReferenceSpace;
+		/// <summary>
+		/// Creates a reference space
+		/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrCreateReferenceSpace.html">xrCreateReferenceSpace</see>
+		/// </summary>
+		public XrResult CreateReferenceSpace(ref XrReferenceSpaceCreateInfo createInfo, out XrSpace space)
+		{
+			if (!m_XrSessionCreated)
+			{
+				space = 0;
+				return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
+			}
+
+			return xrCreateReferenceSpace(m_XrSession, ref createInfo, out space);
+		}
+
+		/// xrDestroySpace
+		OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
+		private XrResult DestroySpace(XrSpace space)
+		{
+			if (space != 0)
+			{
+				return xrDestroySpace(space);
+			}
+			return XrResult.XR_ERROR_REFERENCE_SPACE_UNSUPPORTED;
+		}
+#if UNITY_STANDALONE
+		private List<XrPassthroughHTC> passthroughList = new List<XrPassthroughHTC>();
+		public List<XrPassthroughHTC> PassthroughList { get { return new List<XrPassthroughHTC>(passthroughList); } }
+		ViveCompositionLayerHelper.xrCreatePassthroughHTCDelegate xrCreatePassthroughHTC;
+		public XrResult CreatePassthroughHTC(XrPassthroughCreateInfoHTC createInfo, out XrPassthroughHTC passthrough)
+		{
+			if (!m_XrSessionCreated)
+			{
+				ERROR("CreatePassthroughHTC() XR_ERROR_SESSION_LOST.");
+				passthrough = 0;
+				return XrResult.XR_ERROR_SESSION_LOST;
+			}
+			if (!m_XrInstanceCreated)
+			{
+				ERROR("CreatePassthroughHTC() XR_ERROR_INSTANCE_LOST.");
+				passthrough = 0;
+				return XrResult.XR_ERROR_INSTANCE_LOST;
+			}
+
+			XrResult res = xrCreatePassthroughHTC(m_XrSession, createInfo, out passthrough);
+			if (res == XrResult.XR_SUCCESS)
+            {
+				passthroughList.Add(passthrough);
+				passthroughIDList.Add(((int)(ulong)passthrough));
+			}
+			else
+				ERROR("CreatePassthroughHTC() "+res);
+			return res;
+		}
+
+		ViveCompositionLayerHelper.xrDestroyPassthroughHTCDelegate xrDestroyPassthroughHTC;
+		public XrResult DestroyPassthroughHTC(XrPassthroughHTC passthrough)
+		{
+			DEBUG("Entry");
+			XrResult res = xrDestroyPassthroughHTC(passthrough);
+			if (res == XrResult.XR_SUCCESS)
+			{
+				passthroughList.Remove(passthrough);
+				passthroughIDList.Remove(((int)(ulong)passthrough));
+			}
+			return res;
+		}
+		/// <summary>
+		/// According to XRInputSubsystem's tracking origin mode, return the corresponding XrSpace.
+		/// </summary>
+		/// <returns></returns>
+		public XrSpace GetTrackingSpace()
+		{
+			var s = GetCurrentAppSpace();
+			Debug.Log("VivePassthrough GetTrackingSpace() s=" + s);
+			return s;
+		}
+#endif
+		private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            /// xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                DEBUG("Get function pointer of xrGetInstanceProcAddr.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                    xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+            }
+            else
+            {
+                ERROR("xrGetInstanceProcAddr");
+                return false;
+            }
+
+            IntPtr funcPtr = IntPtr.Zero;
+            /// xrGetSystemProperties
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetSystemProperties.");
+                    xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetSystemProperties");
+                return false;
+            }
+			/// xrEnumerateReferenceSpaces
+			if (XrGetInstanceProcAddr(xrInstance, "xrEnumerateReferenceSpaces", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrEnumerateReferenceSpaces.");
+					xrEnumerateReferenceSpaces = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrEnumerateReferenceSpacesDelegate)) as OpenXRHelper.xrEnumerateReferenceSpacesDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrEnumerateReferenceSpaces");
+				return false;
+			}
+			/// xrCreateReferenceSpace
+			if (XrGetInstanceProcAddr(xrInstance, "xrCreateReferenceSpace", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrCreateReferenceSpace.");
+					xrCreateReferenceSpace = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrCreateReferenceSpaceDelegate)) as OpenXRHelper.xrCreateReferenceSpaceDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrCreateReferenceSpace");
+				return false;
+			}
+			/// xrDestroySpace
+			if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrDestroySpace.");
+					xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrDestroySpace");
+				return false;
+			}
+#if UNITY_STANDALONE
+			/// xrCreatePassthroughHTC
+			if (XrGetInstanceProcAddr(xrInstance, "xrCreatePassthroughHTC", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrCreatePassthroughHTC.");
+					xrCreatePassthroughHTC = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(ViveCompositionLayerHelper.xrCreatePassthroughHTCDelegate)) as ViveCompositionLayerHelper.xrCreatePassthroughHTCDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrCreatePassthroughHTC");
+				return false;
+			}
+			/// xrCreatePassthroughHTC
+			if (XrGetInstanceProcAddr(xrInstance, "xrDestroyPassthroughHTC", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrDestroyPassthroughHTC.");
+					xrDestroyPassthroughHTC = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(ViveCompositionLayerHelper.xrDestroyPassthroughHTCDelegate)) as ViveCompositionLayerHelper.xrDestroyPassthroughHTCDelegate;
+				}
+			}
+			else
+			{
+				ERROR("xrDestroyPassthroughHTC");
+				return false;
+			}
+#endif
+#if UNITY_ANDROID
+			if (HTCPassthrough_GetFuncAddrs(xrInstance, xrGetInstanceProcAddr) == XrResult.XR_SUCCESS)
+			{
+				DEBUG("Get function pointers in native.");
+			}
+			else
+			{
+				ERROR("HTCPassthrough_GetFuncAddrs");
+				return false;
+			}
+#endif
+			return true;
+        }
+#endregion
+
+#region Wrapper Functions
+		private const string ExtLib = "viveopenxr";
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_CreatePassthrough")]
+		private static extern int VIVEOpenXR_HTCPassthrough_CreatePassthrough(XrSession session, LayerType layerType, PassthroughLayerForm layerForm, uint compositionDepth = 0);
+		/// <summary>
+		/// Create Passthrough.
+		/// </summary>
+		public int HTCPassthrough_CreatePassthrough(LayerType layerType, PassthroughLayerForm layerForm, OnPassthroughSessionDestroyDelegate onDestroyPassthroughHandler, uint compositionDepth = 0)
+		{
+			if (!m_XrSessionCreated || m_XrSession == 0)
+			{
+				ERROR("Xr Session not found");
+				return 0;
+			}
+
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_CreatePassthrough: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return 0;
+			}
+
+			int passthroughID = VIVEOpenXR_HTCPassthrough_CreatePassthrough(m_XrSession, layerType, layerForm, compositionDepth);
+
+			if (passthroughID != 0)
+			{
+				passthroughIDList.Add(passthroughID);
+				OnPassthroughSessionDestroyHandlerDictionary.Add(passthroughID, onDestroyPassthroughHandler);
+			}
+
+			return passthroughID;
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetAlpha")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetAlpha(int passthroughID, float alpha);
+		/// <summary>
+		/// Set Passthough Alpha.
+		/// </summary>
+		public bool HTCPassthrough_SetAlpha(int passthroughID, float alpha)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetAlpha: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetAlpha(passthroughID, alpha);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetLayerType")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetLayerType(int passthroughID, LayerType layerType, uint compositionDepth = 0);
+		/// <summary>
+		/// Set Passthough Layer Type.
+		/// </summary>
+		public bool HTCPassthrough_SetLayerType(int passthroughID, LayerType layerType, uint compositionDepth = 0)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetLayerType: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetLayerType(passthroughID, layerType, compositionDepth);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMesh")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMesh(int passthroughID, uint vertexCount, [In, Out] XrVector3f[] vertexBuffer, uint indexCount, [In, Out] uint[] indexBuffer);
+		/// <summary>
+		/// Set Passthough Mesh.
+		/// </summary>
+		public bool HTCPassthrough_SetMesh(int passthroughID, uint vertexCount, [In, Out] XrVector3f[] vertexBuffer, uint indexCount, [In, Out] uint[] indexBuffer)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMesh: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMesh(passthroughID, vertexCount, vertexBuffer, indexCount, indexBuffer);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransform")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMeshTransform(int passthroughID, XrSpace meshSpace, XrPosef meshPose, XrVector3f meshScale);
+		/// <summary>
+		/// Set Passthough Mesh Transform.
+		/// </summary>
+		public bool HTCPassthrough_SetMeshTransform(int passthroughID, XrSpace meshSpace, XrPosef meshPose, XrVector3f meshScale)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMeshTransform: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMeshTransform(passthroughID, meshSpace, meshPose, meshScale);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformSpace")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMeshTransformSpace(int passthroughID, XrSpace meshSpace);
+		/// <summary>
+		/// Set Passthough Mesh Transform Space.
+		/// </summary>
+		public bool HTCPassthrough_SetMeshTransformSpace(int passthroughID, XrSpace meshSpace)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMeshTransformSpace: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMeshTransformSpace(passthroughID, meshSpace);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformPosition")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMeshTransformPosition(int passthroughID, XrVector3f meshPosition);
+		/// <summary>
+		/// Set Passthough Mesh Transform Position.
+		/// </summary>
+		public bool HTCPassthrough_SetMeshTransformPosition(int passthroughID, XrVector3f meshPosition)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMeshTransformPosition: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMeshTransformPosition(passthroughID, meshPosition);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformOrientation")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMeshTransformOrientation(int passthroughID, XrQuaternionf meshOrientation);
+		/// <summary>
+		/// Set Passthough Mesh Transform orientation.
+		/// </summary>
+		public bool HTCPassthrough_SetMeshTransformOrientation(int passthroughID, XrQuaternionf meshOrientation)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMeshTransformOrientation: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMeshTransformOrientation(passthroughID, meshOrientation);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformScale")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_SetMeshTransformScale(int passthroughID, XrVector3f meshScale);
+		/// <summary>
+		/// Set Passthough Mesh Transform scale.
+		/// </summary>
+		public bool HTCPassthrough_SetMeshTransformScale(int passthroughID, XrVector3f meshScale)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_SetMeshTransformScale: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_SetMeshTransformScale(passthroughID, meshScale);
+		}
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_DestroyPassthrough")]
+		private static extern bool VIVEOpenXR_HTCPassthrough_DestroyPassthrough(int passthroughID);
+		/// <summary>
+		/// Destroy Passthough.
+		/// </summary>
+		public bool HTCPassthrough_DestroyPassthrough(int passthroughID)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("HTCPassthrough_DestroyPassthrough: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return false;
+			}
+
+			bool destroyed = VIVEOpenXR_HTCPassthrough_DestroyPassthrough(passthroughID);
+
+			if (destroyed)
+			{
+				passthroughIDList.Remove(passthroughID);
+				OnPassthroughSessionDestroyHandlerDictionary.Remove(passthroughID);
+			}
+
+			return destroyed;
+		}
+#endregion
+
+#region Hook native functions
+
+		[DllImportAttribute(ExtLib, EntryPoint = "htcpassthrough_GetFuncAddrs")]
+		private static extern XrResult VIVEOpenXR_HTCPassthrough_GetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr);
+		private XrResult HTCPassthrough_GetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr)
+		{
+			if (!HTCPassthroughExtensionEnabled)
+			{
+				ERROR("VIVEOpenXR_HTCPassthrough_GetFuncAddrs: " + kOpenxrExtensionStrings + " is NOT enabled.");
+				return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+			}
+
+			return VIVEOpenXR_HTCPassthrough_GetFuncAddrs(xrInstance, xrGetInstanceProcAddrFuncPtr);
+		}
+
+#endregion
+
+#region Helper Funcs
+		/// <summary>
+		/// Helper function to get XrSpace from space type.
+		/// </summary>
+		public XrSpace GetXrSpaceFromSpaceType(ProjectedPassthroughSpaceType spaceType)
+		{
+			XrSpace meshSpace = 0;
+			switch (spaceType)
+			{
+				case ProjectedPassthroughSpaceType.Headlock:
+					meshSpace = HeadLockSpace;
+					break;
+				case ProjectedPassthroughSpaceType.Worldlock:
+				default:
+					XRInputSubsystem subsystem = null;
+					SubsystemManager.GetInstances(inputSubsystems);
+					if (inputSubsystems.Count > 0)
+					{
+						subsystem = inputSubsystems[0];
+					}
+
+					if (subsystem != null)
+					{
+						TrackingOriginModeFlags trackingOriginMode = subsystem.GetTrackingOriginMode();
+
+						switch (trackingOriginMode)
+						{
+							default:
+							case TrackingOriginModeFlags.Floor:
+								meshSpace = WorldLockSpaceOriginOnFloor;
+								break;
+							case TrackingOriginModeFlags.Device:
+								meshSpace = WorldLockSpaceOriginOnHead;
+								break;
+						}
+					}
+					else
+					{
+						meshSpace = WorldLockSpaceOriginOnFloor;
+					}
+					break;
+			}
+
+			return meshSpace;
+		}
+
+#endregion
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerPassthrough.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0e78888b9743d564482402fe284c9126
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerPassthroughHelper.cs

@@ -0,0 +1,46 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace VIVE.OpenXR.CompositionLayer.Passthrough
+{
+	[Obsolete("This enumeration is deprecated. Please use XrStructureType instead.")]
+	//[StructLayout(LayoutKind.Sequential)]
+    public enum XrStructureTypeHTC
+    {
+		XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC = 1000317001,
+		XR_TYPE_PASSTHROUGH_COLOR_HTC = 1000317002,
+		XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC = 1000317003,
+		XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004,
+	}
+
+	[Obsolete("This enumeration is deprecated. Please use VIVE.OpenXR.Passthrough.PassthroughLayerForm instead.")]
+	public enum PassthroughLayerForm
+	{
+		///<summary> Fullscreen Passthrough Form</summary>
+		Planar = 0,
+		///<summary> Projected Passthrough Form</summary>
+		Projected = 1
+	}
+
+	[Obsolete("This enumeration is deprecated. Please use VIVE.OpenXR.Passthrough.ProjectedPassthroughSpaceType instead.")]
+	public enum ProjectedPassthroughSpaceType
+	{
+		///<summary> 
+		/// XR_REFERENCE_SPACE_TYPE_VIEW at (0,0,0) with orientation (0,0,0,1) 
+		///</summary>
+		Headlock = 0,
+		///<summary> 
+		/// When TrackingOriginMode is TrackingOriginModeFlags.Floor:
+		/// XR_REFERENCE_SPACE_TYPE_STAGE at (0,0,0) with orientation (0,0,0,1) 
+		/// 
+		/// When TrackingOriginMode is TrackingOriginModeFlags.Device:
+		/// XR_REFERENCE_SPACE_TYPE_LOCAL at (0,0,0) with orientation (0,0,0,1) 
+		/// 
+		///</summary>
+		Worldlock = 1
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/CompositionLayer/Scripts/ViveCompositionLayerPassthroughHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58a0974face1c1b448dab924ce82c5ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisableVisibilityMask.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: beb3432f6f958f94bb911a9b9b4174e1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisableVisibilityMask/DisableVisibilityMask.cs

@@ -0,0 +1,19 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace VIVE.OpenXR {
+    public class DisableVisibilityMask
+    {
+        static GameObject Provider;
+
+        [RuntimeInitializeOnLoadMethod]
+        static void Start()
+        {
+            Provider = new GameObject();
+            Provider.AddComponent<VisibilityMaskDisabler>();
+        }
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisableVisibilityMask/DisableVisibilityMask.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f48023d9309a7f4bb46ff61a3b9523f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisableVisibilityMask/VisibilityMaskDisabler.cs

@@ -0,0 +1,39 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.XR;
+
+namespace VIVE.OpenXR
+{
+    public class VisibilityMaskDisabler : MonoBehaviour
+    {
+        const string TAG = "VisibilityMaskDisabler";
+        void Enable()
+        {
+            DontDestroyOnLoad(gameObject);
+        }
+
+        private void Update()
+        {
+            if (NeedWorkAround() && XRSettings.occlusionMaskScale != 0.0f)
+            {
+                Debug.Log(TAG + "Try set scale to 0");
+                XRSettings.occlusionMaskScale = 0.0f;
+            }
+        }
+
+        bool NeedWorkAround()
+        {
+            if (SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Vulkan && (XRSettings.stereoRenderingMode == XRSettings.StereoRenderingMode.SinglePass || XRSettings.stereoRenderingMode == XRSettings.StereoRenderingMode.SinglePassMultiview))
+            {
+                return true;
+            }
+            return false;
+        }
+    }
+
+
+}
+

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisableVisibilityMask/VisibilityMaskDisabler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a9a8ed5424d972e42a118a829088c5f2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 248e0c72c6c43ef4b8f2bef4f4a5901a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6fd4c5098d66cc74294f6c590e9e24cb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Documentation/OpenXRExtensions.md

@@ -0,0 +1,206 @@
+# 12.54. XR_FB_display_refresh_rate
+## Name String
+    XR_FB_display_refresh_rate
+## Revision
+1
+## Overview
+
+On platforms which support dynamically adjusting the display refresh rate, application developers may request a specific display refresh rate in order to improve the overall user experience, examples include:
+
+A video application may choose a display refresh rate which better matches the video content playback rate in order to achieve smoother video frames.
+
+An application which can support a higher frame rate may choose to render at the higher rate to improve the overall perceptual quality, for example, lower latency and less flicker.
+
+This extension allows:
+
+An application to identify what display refresh rates the session supports and the current display refresh rate.
+
+An application to request a display refresh rate to indicate its preference to the runtime.
+
+An application to receive notification of changes to the display refresh rate which are delivered via events.
+
+In order to enable the functionality of this extension, the application must pass the name of the extension into xrCreateInstance via the XrInstanceCreateInfo::enabledExtensionNames parameter as indicated in the Extensions section.
+
+New Object Types
+
+New Flag Types
+
+New Enum Constants
+
+XrStructureType enumeration is extended with:
+
+XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB
+
+XrResult enumeration is extended with:
+
+XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB
+
+New Enums
+
+New Structures
+
+Receiving the XrEventDataDisplayRefreshRateChangedFB event structure indicates that the display refresh rate has changed.
+
+The XrEventDataDisplayRefreshRateChangedFB structure is defined as:
+
+// Provided by XR_FB_display_refresh_rate
+typedef struct XrEventDataDisplayRefreshRateChangedFB {
+    XrStructureType    type;
+    const void*        next;
+    float              fromDisplayRefreshRate;
+    float              toDisplayRefreshRate;
+} XrEventDataDisplayRefreshRateChangedFB;
+Member Descriptions
+type is the XrStructureType of this structure.
+
+next is NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+
+fromDisplayRefreshRate is the previous display refresh rate.
+
+toDisplayRefreshRate is the new display refresh rate.
+
+Valid Usage (Implicit)
+The XR_FB_display_refresh_rate extension must be enabled prior to using XrEventDataDisplayRefreshRateChangedFB
+
+type must be XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB
+
+next must be NULL or a valid pointer to the next structure in a structure chain
+
+New Functions
+
+The xrEnumerateDisplayRefreshRatesFB function is defined as:
+
+// Provided by XR_FB_display_refresh_rate
+XrResult xrEnumerateDisplayRefreshRatesFB(
+    XrSession                                   session,
+    uint32_t                                    displayRefreshRateCapacityInput,
+    uint32_t*                                   displayRefreshRateCountOutput,
+    float*                                      displayRefreshRates);
+Parameter Descriptions
+session is the session that enumerates the supported display refresh rates.
+
+displayRefreshRateCapacityInput is the capacity of the displayRefreshRates, or 0 to retrieve the required capacity.
+
+displayRefreshRateCountOutput is a pointer to the count of float displayRefreshRates written, or a pointer to the required capacity in the case that displayRefreshRateCapacityInput is insufficient.
+
+displayRefreshRates is a pointer to an array of float display refresh rates, but can be NULL if displayRefreshRateCapacityInput is 0.
+
+See Buffer Size Parameters chapter for a detailed description of retrieving the required displayRefreshRates size.
+
+xrEnumerateDisplayRefreshRatesFB enumerates the display refresh rates supported by the current session. Display refresh rates must be in order from lowest to highest supported display refresh rates. Runtimes must always return identical buffer contents from this enumeration for the lifetime of the session.
+
+Valid Usage (Implicit)
+The XR_FB_display_refresh_rate extension must be enabled prior to calling xrEnumerateDisplayRefreshRatesFB
+
+session must be a valid XrSession handle
+
+displayRefreshRateCountOutput must be a pointer to a uint32_t value
+
+If displayRefreshRateCapacityInput is not 0, displayRefreshRates must be a pointer to an array of displayRefreshRateCapacityInput float values
+
+Return Codes
+Success
+XR_SUCCESS
+
+XR_SESSION_LOSS_PENDING
+
+Failure
+XR_ERROR_FUNCTION_UNSUPPORTED
+
+XR_ERROR_VALIDATION_FAILURE
+
+XR_ERROR_RUNTIME_FAILURE
+
+XR_ERROR_HANDLE_INVALID
+
+XR_ERROR_INSTANCE_LOST
+
+XR_ERROR_SESSION_LOST
+
+XR_ERROR_SIZE_INSUFFICIENT
+
+The xrGetDisplayRefreshRateFB function is defined as:
+
+// Provided by XR_FB_display_refresh_rate
+XrResult xrGetDisplayRefreshRateFB(
+    XrSession                                   session,
+    float*                                      displayRefreshRate);
+Parameter Descriptions
+session is the XrSession to query.
+
+displayRefreshRate is a pointer to a float into which the current display refresh rate will be placed.
+
+xrGetDisplayRefreshRateFB retrieves the current display refresh rate.
+
+Valid Usage (Implicit)
+The XR_FB_display_refresh_rate extension must be enabled prior to calling xrGetDisplayRefreshRateFB
+
+session must be a valid XrSession handle
+
+displayRefreshRate must be a pointer to a float value
+
+Return Codes
+Success
+XR_SUCCESS
+
+XR_SESSION_LOSS_PENDING
+
+Failure
+XR_ERROR_FUNCTION_UNSUPPORTED
+
+XR_ERROR_VALIDATION_FAILURE
+
+XR_ERROR_RUNTIME_FAILURE
+
+XR_ERROR_HANDLE_INVALID
+
+XR_ERROR_INSTANCE_LOST
+
+XR_ERROR_SESSION_LOST
+
+The xrRequestDisplayRefreshRateFB function is defined as:
+
+// Provided by XR_FB_display_refresh_rate
+XrResult xrRequestDisplayRefreshRateFB(
+    XrSession                                   session,
+    float                                       displayRefreshRate);
+Parameter Descriptions
+session is a valid XrSession handle.
+
+displayRefreshRate is 0.0f or a supported display refresh rate. Supported display refresh rates are indicated by xrEnumerateDisplayRefreshRatesFB.
+
+xrRequestDisplayRefreshRateFB provides a mechanism for an application to request the system to dynamically change the display refresh rate to the application preferred value. The runtime must return XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB if displayRefreshRate is not either 0.0f or one of the values enumerated by xrEnumerateDisplayRefreshRatesFB. A display refresh rate of 0.0f indicates the application has no preference.
+
+Note that this is only a request and does not guarantee the system will switch to the requested display refresh rate.
+
+Valid Usage (Implicit)
+The XR_FB_display_refresh_rate extension must be enabled prior to calling xrRequestDisplayRefreshRateFB
+
+session must be a valid XrSession handle
+
+Return Codes
+Success
+XR_SUCCESS
+
+XR_SESSION_LOSS_PENDING
+
+Failure
+XR_ERROR_FUNCTION_UNSUPPORTED
+
+XR_ERROR_VALIDATION_FAILURE
+
+XR_ERROR_RUNTIME_FAILURE
+
+XR_ERROR_HANDLE_INVALID
+
+XR_ERROR_INSTANCE_LOST
+
+XR_ERROR_SESSION_LOST
+
+XR_ERROR_FEATURE_UNSUPPORTED
+
+XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB
+
+Issues
+
+Changing the display refresh rate from its system default does not come without trade-offs. Increasing the display refresh rate puts more load on the entire system and can lead to thermal degradation. Conversely, lowering the display refresh rate can provide better thermal sustainability but at the cost of more perceptual issues, like higher latency and flickering.

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 77f492ea9a608234294b51cf030292f6
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e3d6a1242bdfeb429ae342486ba096e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/ViveDisplayRefreshRate.cs

@@ -0,0 +1,270 @@
+// "VIVE SDK 
+// © 2020 HTC Corporation. All Rights Reserved.
+//
+// Unless otherwise required by copyright law and practice,
+// upon the execution of HTC SDK license agreement,
+// HTC grants you access to and use of the VIVE SDK(s).
+// You shall fully comply with all of HTC’s SDK license agreement terms and
+// conditions signed by you and all SDK and API requirements,
+// specifications, and documentation provided by HTC to You."
+
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine;
+using System.Runtime.InteropServices;
+using System;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.DisplayRefreshRate
+{
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Display Refresh Rate",
+        BuildTargetGroups = new[] { BuildTargetGroup.Android},
+        Company = "HTC",
+        Desc = "Support the display refresh rate.",
+        DocumentationLink = "..\\Documentation",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Version = "1.0.0",
+        FeatureId = featureId)]
+#endif
+    public class ViveDisplayRefreshRate : OpenXRFeature
+	{
+        const string LOG_TAG = "VIVE.OpenXR.DisplayRefreshRate";
+        void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+        /// <summary>
+        /// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_FB_display_refresh_rate">12.54. XR_FB_display_refresh_rate</see>.
+        /// </summary>
+        public const string kOpenxrExtensionString = "XR_FB_display_refresh_rate";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.displayrefreshrate";
+
+        #region OpenXR Life Cycle
+
+        protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+        {
+            ViveInterceptors.Instance.AddRequiredFunction("xrPollEvent");
+            return ViveInterceptors.Instance.HookGetInstanceProcAddr(func);
+        }
+
+	    private XrInstance m_XrInstance = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The created instance.</param>
+        /// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+            {
+                WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+                return false;
+            }
+
+            m_XrInstance = xrInstance;
+            DEBUG("OnInstanceCreate() " + m_XrInstance);
+
+            return GetXrFunctionDelegates(m_XrInstance);
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyInstance">xrDestroyInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The instance to destroy.</param>
+        protected override void OnInstanceDestroy(ulong xrInstance)
+        {
+            m_XrInstance = 0;
+            DEBUG("OnInstanceDestroy() " + xrInstance);
+        }
+
+        private XrSystemId m_XrSystemId = 0;
+        /// <summary>
+        /// Called when the <see cref="XrSystemId">XrSystemId</see> retrieved by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystem">xrGetSystem</see> is changed.
+        /// </summary>
+        /// <param name="xrSystem">The system id.</param>
+        protected override void OnSystemChange(ulong xrSystem)
+        {
+            m_XrSystemId = xrSystem;
+            DEBUG("OnSystemChange() " + m_XrSystemId);
+        }
+
+		private XrSession m_XrSession = 0;
+
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateSession">xrCreateSession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The created session ID.</param>
+        protected override void OnSessionCreate(ulong xrSession)
+        {
+            m_XrSession = xrSession;
+            DEBUG("OnSessionCreate() " + m_XrSession);
+
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroySession">xrDestroySession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The session ID to destroy.</param>
+        protected override void OnSessionDestroy(ulong xrSession)
+        {
+            DEBUG("OnSessionDestroy() " + xrSession);
+
+            m_XrSession = 0;
+        }
+        #endregion
+
+        #region OpenXR function delegates
+        /// xrGetInstanceProcAddr
+        OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+
+		//xrRequestDisplayRefreshRateFB
+		OpenXRHelper.xrRequestDisplayRefreshRateFBDelegate xrRequestDisplayRefreshRateFB;
+
+		//xrGetDisplayRefreshRateFB
+		OpenXRHelper.xrGetDisplayRefreshRateFBDelegate xrGetDisplayRefreshRateFB;
+
+		//xrEnumerateDisplayRefreshRatesFB
+		OpenXRHelper.xrEnumerateDisplayRefreshRatesFBDelegate xrEnumerateDisplayRefreshRatesFB;
+
+
+        private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            /// xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                DEBUG("Get function pointer of xrGetInstanceProcAddr.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                    xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+            }
+            else
+            {
+                ERROR("xrGetInstanceProcAddr");
+                return false;
+            }
+
+            IntPtr funcPtr = IntPtr.Zero;
+			DEBUG("Try Get function pointer of xrRequestDisplayRefreshRateFB.");
+
+			/// xrRequestDisplayRefreshRateFB
+			if (XrGetInstanceProcAddr(xrInstance, "xrRequestDisplayRefreshRateFB", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrRequestDisplayRefreshRateFB.");
+					xrRequestDisplayRefreshRateFB = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrRequestDisplayRefreshRateFBDelegate)) as OpenXRHelper.xrRequestDisplayRefreshRateFBDelegate;
+				}
+				else
+				{
+					ERROR("0. Get function pointer of xrRequestDisplayRefreshRateFB failed.");
+				}
+			}
+			else
+			{
+				ERROR("1. Get function pointer of xrRequestDisplayRefreshRateFB failed.");
+			}
+
+			/// xrGetDisplayRefreshRateFB
+			if (XrGetInstanceProcAddr(xrInstance, "xrGetDisplayRefreshRateFB", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrGetDisplayRefreshRateFB.");
+					xrGetDisplayRefreshRateFB = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrGetDisplayRefreshRateFBDelegate)) as OpenXRHelper.xrGetDisplayRefreshRateFBDelegate;
+				}
+				else
+				{
+					ERROR("0. Get function pointer of xrGetDisplayRefreshRateFB failed.");
+				}
+			}
+			else
+			{
+				ERROR("1. Get function pointer of xrGetDisplayRefreshRateFB failed.");
+			}
+
+			/// xrEnumerateDisplayRefreshRatesFB
+			if (XrGetInstanceProcAddr(xrInstance, "xrEnumerateDisplayRefreshRatesFB", out funcPtr) == XrResult.XR_SUCCESS)
+			{
+				if (funcPtr != IntPtr.Zero)
+				{
+					DEBUG("Get function pointer of xrEnumerateDisplayRefreshRatesFB.");
+					xrEnumerateDisplayRefreshRatesFB = Marshal.GetDelegateForFunctionPointer(
+						funcPtr,
+						typeof(OpenXRHelper.xrEnumerateDisplayRefreshRatesFBDelegate)) as OpenXRHelper.xrEnumerateDisplayRefreshRatesFBDelegate;
+				}
+				else
+				{
+					ERROR("0. Get function pointer of xrEnumerateDisplayRefreshRatesFB failed.");
+				}
+			}
+			else
+			{
+				ERROR("1. Get function pointer of xrEnumerateDisplayRefreshRatesFB failed.");
+			}
+
+			return true;
+        }
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrRequestDisplayRefreshRateFB">xrRequestDisplayRefreshRateFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRate"></param>
+		/// <returns></returns>
+		public XrResult RequestDisplayRefreshRate(float displayRefreshRate)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled("XR_FB_display_refresh_rate"))
+			{
+				WARNING("RequestDisplayRefreshRate: XR_FB_display_refresh_rate is NOT enabled.");
+				return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+			}
+			return xrRequestDisplayRefreshRateFB(m_XrSession, displayRefreshRate);
+		}
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetDisplayRefreshRateFB">xrGetDisplayRefreshRateFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRate"></param>
+		/// <returns></returns>
+		public XrResult GetDisplayRefreshRate(out float displayRefreshRate)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled("XR_FB_display_refresh_rate"))
+			{
+				WARNING("GetDisplayRefreshRate: XR_FB_display_refresh_rate is NOT enabled.");
+				displayRefreshRate = 90.0f;
+				return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+			}
+			return xrGetDisplayRefreshRateFB(m_XrSession, out displayRefreshRate);
+		}
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrEnumerateDisplayRefreshRatesFB">xrEnumerateDisplayRefreshRatesFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRateCapacityInput"></param>
+		/// <param name="displayRefreshRateCountOutput"></param>
+		/// <param name="displayRefreshRates"></param>
+		/// <returns></returns>
+		public XrResult EnumerateDisplayRefreshRates(UInt32 displayRefreshRateCapacityInput, out UInt32 displayRefreshRateCountOutput, out float displayRefreshRates)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled("XR_FB_display_refresh_rate"))
+			{
+				WARNING("EnumerateDisplayRefreshRates: XR_FB_display_refresh_rate is NOT enabled.");
+				displayRefreshRateCountOutput = 0;
+				displayRefreshRates = 90.0f;
+				return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+			}
+			return xrEnumerateDisplayRefreshRatesFB(m_XrSession, displayRefreshRateCapacityInput, out displayRefreshRateCountOutput, out displayRefreshRates);
+		}
+        #endregion
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/ViveDisplayRefreshRate.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c6529da49ed6c34e9fc93a1ccfd9d4f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/ViveDisplayRefreshRateHelper.cs

@@ -0,0 +1,111 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace VIVE.OpenXR.DisplayRefreshRate
+{
+	// -------------------- 12.52. XR_FB_display_refresh_rate --------------------
+	#region New Structures
+	/// <summary>
+	/// On platforms which support dynamically adjusting the display refresh rate, application developers may request a specific display refresh rate in order to improve the overall user experience.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrEventDataDisplayRefreshRateChangedFB
+	{
+		/// <summary>
+		/// The <see cref="XrStructureType"/> of this structure.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// fromDisplayRefreshRate is the previous display refresh rate.
+		/// </summary>
+		public float fromDisplayRefreshRate;
+		/// <summary>
+		/// toDisplayRefreshRate is the new display refresh rate.
+		/// </summary>
+		public float toDisplayRefreshRate;
+
+		/// <summary>
+		/// The XR_FB_display_refresh_rate extension must be enabled prior to using XrEventDataDisplayRefreshRateChangedFB.
+		/// </summary>
+		public XrEventDataDisplayRefreshRateChangedFB(XrStructureType in_type, IntPtr in_next, float in_fromDisplayRefreshRate, float in_toDisplayRefreshRate)
+		{
+			type = in_type;
+			next = in_next;
+			fromDisplayRefreshRate = in_fromDisplayRefreshRate;
+			toDisplayRefreshRate = in_toDisplayRefreshRate;
+		}
+		/// <summary>
+		/// Retrieves the identity value of XrEventDataDisplayRefreshRateChangedFB.
+		/// </summary>
+		public static XrEventDataDisplayRefreshRateChangedFB identity
+		{
+			get
+			{
+				return new XrEventDataDisplayRefreshRateChangedFB(XrStructureType.XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB, IntPtr.Zero, 0.0f, 0.0f); // user is default present
+			}
+		}
+		public static bool Get(XrEventDataBuffer eventDataBuffer, out XrEventDataDisplayRefreshRateChangedFB eventDataDisplayRefreshRateChangedFB)
+		{
+			eventDataDisplayRefreshRateChangedFB = identity;
+
+			if (eventDataBuffer.type == XrStructureType.XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB)
+			{
+				eventDataDisplayRefreshRateChangedFB.next = eventDataBuffer.next;
+				eventDataDisplayRefreshRateChangedFB.fromDisplayRefreshRate = BitConverter.ToSingle(eventDataBuffer.varying, 0);
+				eventDataDisplayRefreshRateChangedFB.toDisplayRefreshRate = BitConverter.ToSingle(eventDataBuffer.varying, 4);
+				return true;
+			}
+
+			return false;
+		}
+	}
+
+	public static class ViveDisplayRefreshRateChanged
+	{
+		public delegate void OnDisplayRefreshRateChanged(float fromDisplayRefreshRate, float toDisplayRefreshRate);
+
+		public static void Listen(OnDisplayRefreshRateChanged callback)
+		{
+			if (!allEventListeners.Contains(callback))
+				allEventListeners.Add(callback);
+		}
+		public static void Remove(OnDisplayRefreshRateChanged callback)
+		{
+			if (allEventListeners.Contains(callback))
+				allEventListeners.Remove(callback);
+		}
+		public static void Send(float fromDisplayRefreshRate, float toDisplayRefreshRate)
+		{
+			int N = 0;
+			if (allEventListeners != null)
+			{
+				N = allEventListeners.Count;
+				for (int i = N - 1; i >= 0; i--)
+				{
+					OnDisplayRefreshRateChanged single = allEventListeners[i];
+					try
+					{
+						single(fromDisplayRefreshRate, toDisplayRefreshRate);
+					}
+					catch (Exception e)
+					{
+						Debug.Log("Event : " + e.ToString());
+						allEventListeners.Remove(single);
+						Debug.Log("Event : A listener is removed due to exception.");
+					}
+				}
+			}
+		}
+
+		private static List<OnDisplayRefreshRateChanged> allEventListeners = new List<OnDisplayRefreshRateChanged>();
+	}
+	#endregion
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/ViveDisplayRefreshRateHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 146db425ea37c2746ad7c9ae08a5a480
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/XR_FB_display_refresh_rate.cs

@@ -0,0 +1,79 @@
+// ===================== 2022 HTC Corporation. All Rights Reserved. ===================
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+using VIVE.OpenXR.DisplayRefreshRate;
+
+namespace VIVE.OpenXR
+{
+    public class XR_FB_display_refresh_rate_defs
+    {
+		public virtual XrResult RequestDisplayRefreshRate(float displayRefreshRate)
+		{
+			return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+		}
+
+		public virtual XrResult GetDisplayRefreshRate(out float displayRefreshRate)
+		{
+			displayRefreshRate = 90.0f;
+			return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+		}
+
+		public virtual XrResult EnumerateDisplayRefreshRates(UInt32 displayRefreshRateCapacityInput, out UInt32 displayRefreshRateCountOutput, out float displayRefreshRates)
+		{
+			displayRefreshRateCountOutput = 0;
+			displayRefreshRates = 90.0f;
+			return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
+		}
+    }
+
+    public class XR_FB_display_refresh_rate
+    {
+        static XR_FB_display_refresh_rate_defs m_Instance = null;
+        public static XR_FB_display_refresh_rate_defs Interop
+        {
+            get
+            {
+                if (m_Instance == null)
+                {
+                    m_Instance = new XR_FB_display_refresh_rate_impls();
+                }
+                return m_Instance;
+            }
+        }
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrRequestDisplayRefreshRateFB">xrRequestDisplayRefreshRateFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRate"></param>
+		/// <returns></returns>
+		public static XrResult RequestDisplayRefreshRate(float displayRefreshRate)
+		{
+			return Interop.RequestDisplayRefreshRate(displayRefreshRate);
+		}
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetDisplayRefreshRateFB">xrGetDisplayRefreshRateFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRate"></param>
+		/// <returns></returns>
+		public static XrResult GetDisplayRefreshRate(out float displayRefreshRate)
+		{
+			return Interop.GetDisplayRefreshRate(out displayRefreshRate);
+		}
+
+		/// <summary>
+		/// Refer to OpenXR <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrEnumerateDisplayRefreshRatesFB">xrEnumerateDisplayRefreshRatesFB</see>.
+		/// </summary>
+		/// <param name="displayRefreshRateCapacityInput"></param>
+		/// <param name="displayRefreshRateCountOutput"></param>
+		/// <param name="displayRefreshRates"></param>
+		/// <returns></returns>
+		public static XrResult EnumerateDisplayRefreshRates(UInt32 displayRefreshRateCapacityInput, out UInt32 displayRefreshRateCountOutput, out float displayRefreshRates)
+		{
+			return Interop.EnumerateDisplayRefreshRates(displayRefreshRateCapacityInput, out displayRefreshRateCountOutput, out displayRefreshRates);
+		}
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/XR_FB_display_refresh_rate.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8862d382ed6b93d499db2e5724af1939
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/XR_FB_display_refresh_rate_impls.cs

@@ -0,0 +1,68 @@
+// ===================== 2022 HTC Corporation. All Rights Reserved. ===================
+
+using System;
+using UnityEngine;
+
+using UnityEngine.XR.OpenXR;
+
+using VIVE.OpenXR.DisplayRefreshRate;
+
+
+namespace VIVE.OpenXR
+{
+    public class XR_FB_display_refresh_rate_impls : XR_FB_display_refresh_rate_defs
+    {
+        const string LOG_TAG = "VIVE.OpenXR.XR_FB_display_refresh_rate_impls";
+        void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+
+        private ViveDisplayRefreshRate feature = null;
+        private void ASSERT_FEATURE() {
+            if (feature == null) { feature = OpenXRSettings.Instance.GetFeature<ViveDisplayRefreshRate>(); }
+        }
+
+		public override XrResult RequestDisplayRefreshRate(float displayRefreshRate)
+		{
+			DEBUG("RequestDisplayRefreshRate");
+			XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+			ASSERT_FEATURE();
+			if (feature)
+			{
+				result = (XrResult)feature.RequestDisplayRefreshRate(displayRefreshRate);
+			}
+
+			return result;
+		}
+
+		public override XrResult GetDisplayRefreshRate(out float displayRefreshRate)
+		{
+			//DEBUG("GetDisplayRefreshRate");
+			XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+			displayRefreshRate = 0.0f;
+
+			ASSERT_FEATURE();
+			if (feature)
+			{
+				result = (XrResult)feature.GetDisplayRefreshRate(out displayRefreshRate);
+			}
+
+			return result;
+		}
+
+		public override XrResult EnumerateDisplayRefreshRates(UInt32 displayRefreshRateCapacityInput, out UInt32 displayRefreshRateCountOutput, out float displayRefreshRates)
+		{
+			DEBUG("EnumerateDisplayRefreshRates");
+			XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+			displayRefreshRateCountOutput = 0;
+			displayRefreshRates = 90.0f;
+
+			ASSERT_FEATURE();
+			if (feature)
+			{
+				result = (XrResult)feature.EnumerateDisplayRefreshRates(displayRefreshRateCapacityInput, out displayRefreshRateCountOutput, out displayRefreshRates);
+			}
+
+			return result;
+		}
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/DisplayRefreshRate/Scripts/XR_FB_display_refresh_rate_impls.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4578bfda663cfda4a9ae76831b9ecc8f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 65a24dbb45287c244bce088cb4a0a8aa
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,676 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine;
+using System.Runtime.InteropServices;
+using System;
+using AOT;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.EyeTracker
+{
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Eye Tracker (Beta)",
+        BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
+        Company = "HTC",
+        Desc = "Support the eye tracker extension.",
+        DocumentationLink = "..\\Documentation",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Version = "1.0.0",
+        FeatureId = featureId)]
+#endif
+    public class ViveEyeTracker : OpenXRFeature
+    {
+        const string LOG_TAG = "VIVE.OpenXR.Eye.ViveEyeTracker";
+        void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+        void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+        void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+        public const string kOpenxrExtensionString = "XR_HTC_eye_tracker";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.eye.tracker";
+
+        #region OpenXR Life Cycle
+        private bool m_XrInstanceCreated = false;
+        private XrInstance m_XrInstance = 0;
+        private static IntPtr xrGetInstanceProcAddr_prev;
+        private static IntPtr WaitFrame_prev;
+        private static XrFrameWaitInfo m_frameWaitInfo;
+        private static XrFrameState m_frameState;
+        protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+        {
+            UnityEngine.Debug.Log("EXT: registering our own xrGetInstanceProcAddr");
+            xrGetInstanceProcAddr_prev = func;
+            return Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame_xrGetInstanceProcAddr);
+        }
+        [MonoPInvokeCallback(typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate))]
+        private static XrResult intercept_xrWaitFrame_xrGetInstanceProcAddr(XrInstance instance, string name, out IntPtr function)
+        {
+            if (xrGetInstanceProcAddr_prev == null || xrGetInstanceProcAddr_prev == IntPtr.Zero)
+            {
+                UnityEngine.Debug.LogError("xrGetInstanceProcAddr_prev is null");
+                function = IntPtr.Zero;
+                return XrResult.XR_ERROR_VALIDATION_FAILURE;
+            }
+
+            // Get delegate of old xrGetInstanceProcAddr.
+            var xrGetProc = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrGetInstanceProcAddrDelegate>(xrGetInstanceProcAddr_prev);
+            XrResult result = xrGetProc(instance, name, out function);
+            if (name == "xrWaitFrame")
+            {
+                WaitFrame_prev = function;
+                m_intercept_xrWaitFrame = intercepted_xrWaitFrame;
+                function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame); ;
+                UnityEngine.Debug.Log("Getting xrWaitFrame func");
+            }
+
+            return result;
+
+        }
+        [MonoPInvokeCallback(typeof(OpenXRHelper.xrWaitFrameDelegate))]
+        private static int intercepted_xrWaitFrame(ulong session, ref XrFrameWaitInfo frameWaitInfo, ref XrFrameState frameState)
+        {
+            // Get delegate of prev xrWaitFrame.
+            var xrWaitFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrWaitFrameDelegate>(WaitFrame_prev);
+            int res = xrWaitFrame(session, ref frameWaitInfo, ref frameState);
+            m_frameWaitInfo = frameWaitInfo;
+            m_frameState = frameState;
+            return res;
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The created instance.</param>
+        /// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+            {
+                WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+                return false;
+            }
+
+            m_XrInstanceCreated = true;
+            m_XrInstance = xrInstance;
+            DEBUG("OnInstanceCreate() " + m_XrInstance);
+            return GetXrFunctionDelegates(m_XrInstance);
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyInstance">xrDestroyInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The instance to destroy.</param>
+        protected override void OnInstanceDestroy(ulong xrInstance)
+        {
+            m_XrInstanceCreated = false;
+            m_XrInstance = 0;
+            DEBUG("OnInstanceDestroy() " + xrInstance);
+        }
+
+        private XrSystemId m_XrSystemId = 0;
+        /// <summary>
+        /// Called when the <see cref="XrSystemId">XrSystemId</see> retrieved by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystem">xrGetSystem</see> is changed.
+        /// </summary>
+        /// <param name="xrSystem">The system id.</param>
+        protected override void OnSystemChange(ulong xrSystem)
+        {
+            m_XrSystemId = xrSystem;
+            DEBUG("OnSystemChange() " + m_XrSystemId);
+        }
+
+        private bool m_XrSessionCreated = false;
+        private XrSession m_XrSession = 0;
+        private bool hasEyeTracker = false;
+        private XrEyeTrackerHTC m_EyeTracker = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateSession">xrCreateSession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The created session ID.</param>
+        protected override void OnSessionCreate(ulong xrSession)
+        {
+            m_XrSession = xrSession;
+            m_XrSessionCreated = true;
+            DEBUG("OnSessionCreate() " + m_XrSession);
+
+            if (CreateEyeTracker()) { DEBUG("OnSessionCreate() m_EyeTracker " + m_EyeTracker); }
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroySession">xrDestroySession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The session ID to destroy.</param>
+        protected override void OnSessionDestroy(ulong xrSession)
+        {
+            DEBUG("OnSessionDestroy() " + xrSession);
+
+            // Eye Tracking is binding with xrSession so we destroy the trackers when xrSession is destroyed.
+            DestroyEyeTracker();
+
+            m_XrSession = 0;
+            m_XrSessionCreated = false;
+        }
+        #endregion
+
+        #region OpenXR function delegates
+        private static readonly OpenXRHelper.xrGetInstanceProcAddrDelegate m_intercept_xrWaitFrame_xrGetInstanceProcAddr
+            = new OpenXRHelper.xrGetInstanceProcAddrDelegate(intercept_xrWaitFrame_xrGetInstanceProcAddr);
+        private static OpenXRHelper.xrWaitFrameDelegate m_intercept_xrWaitFrame;
+        /// xrGetInstanceProcAddr
+        OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+
+        /// xrGetSystemProperties
+        OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
+        private XrResult GetSystemProperties(ref XrSystemProperties properties)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetSystemProperties() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetSystemProperties() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
+        }
+
+        /// xrDestroySpace
+        OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
+        private XrResult DestroySpace(XrSpace space)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("DestroySpace() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("DestroySpace() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrDestroySpace(space);
+        }
+
+        ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate xrCreateEyeTrackerHTC;
+        private XrResult CreateEyeTrackerHTC(ref XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("CreateEyeTrackerHTC() XR_ERROR_SESSION_LOST.");
+                eyeTracker = 0;
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("CreateEyeTrackerHTC() XR_ERROR_INSTANCE_LOST.");
+                eyeTracker = 0;
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrCreateEyeTrackerHTC(m_XrSession, ref createInfo, out eyeTracker);
+        }
+
+        ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate xrDestroyEyeTrackerHTC;
+        private XrResult DestroyEyeTrackerHTC(XrEyeTrackerHTC eyeTracker)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("DestroyEyeTrackerHTC() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("DestroyEyeTrackerHTC() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrDestroyEyeTrackerHTC(eyeTracker);
+        }
+
+        ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate xrGetEyeGazeDataHTC;
+        private XrResult GetEyeGazeDataHTC(XrEyeTrackerHTC eyeTracker,ref XrEyeGazeDataInfoHTC gazeInfo, ref XrEyeGazeDataHTC eyeGazes)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetEyeGazeDataHTC() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetEyeGazeDataHTC() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            XrResult res =  xrGetEyeGazeDataHTC(eyeTracker,ref gazeInfo,ref eyeGazes);
+            return res;
+        }
+        ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate xrGetEyePupilDataHTC;
+
+        private XrResult GetEyePupilDataHTC(XrEyeTrackerHTC eyeTracker,ref XrEyePupilDataInfoHTC pupilDataInfo,ref XrEyePupilDataHTC pupilData)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetEyePupilData() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetEyePupilData() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+            return xrGetEyePupilDataHTC(eyeTracker,ref pupilDataInfo, ref pupilData);
+        }
+        ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC xrGetEyeGeometricDataHTC;
+        private XrResult GetEyeGeometricDataHTC(XrEyeTrackerHTC eyeTracker,
+            ref XrEyeGeometricDataInfoHTC info,
+            ref XrEyeGeometricDataHTC eyeGeometricData)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetEyeGeometricData() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetEyeGeometricData() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+            return xrGetEyeGeometricDataHTC(eyeTracker,ref info, ref eyeGeometricData);
+        }
+
+        private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            /// xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                DEBUG("Get function pointer of xrGetInstanceProcAddr.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                    xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+            }
+            else
+            {
+                ERROR("xrGetInstanceProcAddr is null");
+                return false;
+            }
+
+            IntPtr funcPtr = IntPtr.Zero;
+            /// xrGetSystemProperties
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetSystemProperties.");
+                    xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetSystemProperties");
+                return false;
+            }
+            /// xrDestroySpace
+            if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrDestroySpace.");
+                    xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrDestroySpace");
+                return false;
+            }
+
+            /// xrCreateEyeTrackerHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrCreateEyeTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrCreateEyeTrackerHTC.");
+                    xrCreateEyeTrackerHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate)) as ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrCreateEyeTrackerHTC");
+                return false;
+            }
+            /// xrDestroyEyeTrackerHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrDestroyEyeTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrDestroyEyeTrackerHTC.");
+                    xrDestroyEyeTrackerHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate)) as ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrDestroyEyeTrackerHTC");
+                return false;
+            }
+            /// xrGetEyeGazeDataHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetEyeGazeDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetEyeGazeDataHTC.");
+                    xrGetEyeGazeDataHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate)) as ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetEyeGazeDataHTC");
+                return false;
+            }
+            /// xrGetEyePupilDataHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetEyePupilDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetEyePupilDataHTC.");
+                    xrGetEyePupilDataHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate)) as ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetEyePupilDataHTC");
+                return false;
+            }
+            /// xrGetEyeGeometricDataHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetEyeGeometricDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetEyeGeometricDataHTC.");
+                    xrGetEyeGeometricDataHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC)) as ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC;
+                }
+            }
+            else
+            {
+                ERROR("xrGetEyeGeometricDataHTC");
+                return false;
+            }
+
+            return true;
+        }
+        #endregion
+
+        XrSystemEyeTrackingPropertiesHTC eyeTrackingSystemProperties;
+        XrSystemProperties systemProperties;
+        private bool IsEyeTrackingSupported()
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("IsEyeTrackingSupported() session is not created.");
+                return false;
+            }
+
+            eyeTrackingSystemProperties.type = XrStructureType.XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_HTC;
+            systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
+            systemProperties.next = Marshal.AllocHGlobal(Marshal.SizeOf(eyeTrackingSystemProperties));
+
+            long offset = 0;
+            if (IntPtr.Size == 4)
+                offset = systemProperties.next.ToInt32();
+            else
+                offset = systemProperties.next.ToInt64();
+
+            IntPtr sys_eye_tracking_prop_ptr = new IntPtr(offset);
+            Marshal.StructureToPtr(eyeTrackingSystemProperties, sys_eye_tracking_prop_ptr, false);
+
+            if (GetSystemProperties(ref systemProperties) == XrResult.XR_SUCCESS)
+            {
+                if (IntPtr.Size == 4)
+                    offset = systemProperties.next.ToInt32();
+                else
+                    offset = systemProperties.next.ToInt64();
+
+                sys_eye_tracking_prop_ptr = new IntPtr(offset);
+                eyeTrackingSystemProperties = (XrSystemEyeTrackingPropertiesHTC)Marshal.PtrToStructure(sys_eye_tracking_prop_ptr, typeof(XrSystemEyeTrackingPropertiesHTC));
+
+                DEBUG("IsEyeTrackingSupported() XrSystemEyeTrackingPropertiesHTC.supportsEyeTracking: "
+                    + eyeTrackingSystemProperties.supportsEyeTracking);
+
+                return (eyeTrackingSystemProperties.supportsEyeTracking > 0);
+            }
+            else
+            {
+                ERROR("IsEyeTrackingSupported() GetSystemProperties failed.");
+            }
+
+            return false;
+        }
+
+        /// <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 XrResult CreateEyeTracker(XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
+        {
+            if (hasEyeTracker)
+            {
+                eyeTracker = m_EyeTracker;
+                DEBUG("CreateEyeTracker() m_EyeTracker: " + eyeTracker + " already created before.");
+                return XrResult.XR_SUCCESS;
+            }
+
+            if (!IsEyeTrackingSupported())
+            {
+                ERROR("CreateEyeTracker() is NOT supported.");
+                eyeTracker = 0;
+                return XrResult.XR_ERROR_VALIDATION_FAILURE;
+            }
+
+            var result = CreateEyeTrackerHTC(ref createInfo, out eyeTracker);
+            DEBUG("CreateEyeTracker() " + result + ", eyeTracker: " + eyeTracker);
+
+            if (result == XrResult.XR_SUCCESS)
+            {
+                hasEyeTracker = true;
+                m_EyeTracker = eyeTracker;
+                DEBUG("CreateEyeTracker() m_EyeTracker " + m_EyeTracker);
+            }
+            return result;
+        }
+        /// <summary>
+        /// An application can create an <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle using CreateEyeTracker.
+        /// </summary>
+        /// <returns>True for success.</returns>
+        public bool CreateEyeTracker()
+        {
+            XrEyeTrackerCreateInfoHTC createInfo = new XrEyeTrackerCreateInfoHTC(
+                in_type: XrStructureType.XR_TYPE_EYE_TRACKER_CREATE_INFO_HTC,
+                in_next: IntPtr.Zero);
+
+            var result = CreateEyeTracker(createInfo, out XrEyeTrackerHTC value);
+            DEBUG("CreateEyeTracker() " +  " tracker: " + value);
+            return result == XrResult.XR_SUCCESS;
+        }
+
+        /// <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 XrResult DestroyEyeTracker(XrEyeTrackerHTC eyeTracker)
+        {
+            XrResult result = DestroyEyeTrackerHTC(eyeTracker);
+            DEBUG("DestroyEyeTracker() " + eyeTracker + ", result: " + result);
+
+            return result;
+        }
+        /// <summary>
+        /// Releases the eye tracker and the underlying resources when the eye tracking experience is over.
+        /// </summary>
+        /// <returns>True for success.</returns>
+        public bool DestroyEyeTracker()
+        {
+            if (!hasEyeTracker)
+            {
+                DEBUG("DestroyEyeTracker() no " + "tracker.");
+                return true;
+            }
+
+            XrResult ret = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            ret = DestroyEyeTracker(m_EyeTracker);
+            hasEyeTracker = false;
+            m_EyeTracker = 0;
+
+            return ret == XrResult.XR_SUCCESS;
+        }
+
+        private XrEyeGazeDataHTC m_gazes = new XrEyeGazeDataHTC();// = new XrEyeGazeDataHTC(XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC, IntPtr.Zero, 0);
+        /// <summary>
+        /// Retrieves an array of <see cref="XrSingleEyeGazeDataHTC">XrSingleEyeGazeDataHTC</see> containing the returned eye gaze directions.
+        /// </summary>
+        /// <param name="out_gazes">Output parameter to retrieve an array of <see cref="XrSingleEyeGazeDataHTC">XrSingleEyeGazeDataHTC</see>.</param>
+        /// <returns>True for success.</returns>
+        public bool GetEyeGazeData(out XrSingleEyeGazeDataHTC[] out_gazes)
+        {
+            m_gazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
+            m_gazes.next = IntPtr.Zero;
+            m_gazes.time =  m_frameState.predictedDisplayTime;
+
+            out_gazes = m_gazes.gaze;
+            XrEyeGazeDataInfoHTC gazeInfo = new XrEyeGazeDataInfoHTC(
+                in_type: XrStructureType.XR_TYPE_EYE_GAZE_DATA_INFO_HTC,
+                in_next: IntPtr.Zero,
+                in_baseSpace: GetCurrentAppSpace(),
+                in_time: m_frameState.predictedDisplayTime);
+            if (GetEyeGazeData(m_EyeTracker, gazeInfo, out m_gazes) == XrResult.XR_SUCCESS)
+            {
+                out_gazes = m_gazes.gaze;
+                return true;
+            }
+            return false;
+        }
+        /// <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 XrResult GetEyeGazeData(XrEyeTrackerHTC eyeTracker, XrEyeGazeDataInfoHTC gazeInfo, out XrEyeGazeDataHTC eyeGazes)
+        {
+            m_gazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
+            m_gazes.next = IntPtr.Zero;
+            m_gazes.time = m_frameState.predictedDisplayTime;
+            eyeGazes = m_gazes;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+            result = GetEyeGazeDataHTC(eyeTracker,ref gazeInfo,ref m_gazes);
+            if (result == XrResult.XR_SUCCESS) { eyeGazes = m_gazes; }
+            
+            return result;
+        }
+
+        private XrEyePupilDataHTC m_eyePupilData = new XrEyePupilDataHTC();
+
+        /// <summary>
+        /// Retrieves an array of <see cref="XrSingleEyePupilDataHTC">XrSingleEyePupilDataHTC</see> containing the returned data for user's pupils.
+        /// </summary>
+        /// <param name="pupilData">Output parameter to retrieve an array of <see cref="XrSingleEyePupilDataHTC">XrSingleEyePupilDataHTC</see>.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public bool GetEyePupilData(out XrSingleEyePupilDataHTC[] pupilData)
+        {
+            m_eyePupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
+            m_eyePupilData.next = IntPtr.Zero;
+            m_eyePupilData.time = m_frameState.predictedDisplayTime;
+            pupilData = m_eyePupilData.pupilData;
+            XrEyePupilDataInfoHTC pupilDataInfo = new XrEyePupilDataInfoHTC(
+                in_type: XrStructureType.XR_TYPE_EYE_PUPIL_DATA_INFO_HTC,
+                in_next: IntPtr.Zero);
+            if (GetEyePupilData(m_EyeTracker, pupilDataInfo, out m_eyePupilData) == XrResult.XR_SUCCESS)
+            {
+                pupilData = m_eyePupilData.pupilData;
+                return true;
+            }
+            return false;
+        }
+
+        /// <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 XrResult GetEyePupilData(XrEyeTrackerHTC eyeTracker, XrEyePupilDataInfoHTC pupilDataInfo, out XrEyePupilDataHTC pupilData)
+        {
+            m_eyePupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
+            m_eyePupilData.next = IntPtr.Zero;
+            m_eyePupilData.time = m_frameState.predictedDisplayTime;
+            pupilData = m_eyePupilData;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+            result = GetEyePupilDataHTC(eyeTracker,ref pupilDataInfo, ref m_eyePupilData);
+            if (result == XrResult.XR_SUCCESS) { pupilData = m_eyePupilData; }
+            return result;
+        }
+
+        private XrEyeGeometricDataHTC m_eyeGeometricData = new XrEyeGeometricDataHTC();//XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC, IntPtr.Zero, 0);
+        /// <param name="geometricData">Output parameter to retrieve an array of <see cref="XrSingleEyeGeometricDataHTC">XrSingleEyeGeometricDataHTC</see>.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public bool GetEyeGeometricData(out XrSingleEyeGeometricDataHTC[] geometricData)
+        {
+            m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
+            m_eyeGeometricData.next = IntPtr.Zero;
+            m_eyeGeometricData.time = m_frameState.predictedDisplayTime;
+            geometricData = m_eyeGeometricData.eyeGeometricData;
+            XrEyeGeometricDataInfoHTC eyeGeometricDataInfo = new XrEyeGeometricDataInfoHTC(
+                in_type: XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_INFO_HTC,
+                in_next: IntPtr.Zero);
+            if (GetEyeGeometricData(m_EyeTracker, eyeGeometricDataInfo, out m_eyeGeometricData) == XrResult.XR_SUCCESS)
+            {
+                geometricData = m_eyeGeometricData.eyeGeometricData;
+                return true;
+            }
+            return false;
+        }
+
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
+        /// <param name="eyeGeometricDataInfo">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 XrResult GetEyeGeometricData(XrEyeTrackerHTC eyeTracker, XrEyeGeometricDataInfoHTC eyeGeometricDataInfo, out XrEyeGeometricDataHTC eyeGeometricData)
+        {
+            m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
+            m_eyeGeometricData.next = IntPtr.Zero;
+            m_eyeGeometricData.time = m_frameState.predictedDisplayTime;
+            eyeGeometricData = m_eyeGeometricData;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+            result = GetEyeGeometricDataHTC(eyeTracker,ref eyeGeometricDataInfo, ref m_eyeGeometricData);
+            if (result == XrResult.XR_SUCCESS) { eyeGeometricData = m_eyeGeometricData; }
+            return result;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9eca1674b64bae840af3a53d3ae576ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/EyeTracker/ViveEyeTrackerHelper.cs

@@ -0,0 +1,426 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace VIVE.OpenXR.EyeTracker
+{
+    /// <summary>
+    /// The XrEyeTrackerHTC handle represents the resources for eye tracking.
+    /// </summary>
+    public struct XrEyeTrackerHTC : IEquatable<UInt64>
+    {
+        private readonly UInt64 value;
+
+        public XrEyeTrackerHTC(UInt64 u)
+        {
+            value = u;
+        }
+
+        public static implicit operator UInt64(XrEyeTrackerHTC equatable)
+        {
+            return equatable.value;
+        }
+        public static implicit operator XrEyeTrackerHTC(UInt64 u)
+        {
+            return new XrEyeTrackerHTC(u);
+        }
+
+        public bool Equals(XrEyeTrackerHTC other)
+        {
+            return value == other.value;
+        }
+        public bool Equals(UInt64 other)
+        {
+            return value == other;
+        }
+        public override bool Equals(object obj)
+        {
+            return obj is XrEyeTrackerHTC && Equals((XrEyeTrackerHTC)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return value.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return value.ToString();
+        }
+
+        public static bool operator ==(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.Equals(b); }
+        public static bool operator !=(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return !a.Equals(b); }
+        public static bool operator >=(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value >= b.value; }
+        public static bool operator <=(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value <= b.value; }
+        public static bool operator >(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value > b.value; }
+        public static bool operator <(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value < b.value; }
+        public static XrEyeTrackerHTC operator +(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value + b.value; }
+        public static XrEyeTrackerHTC operator -(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value - b.value; }
+        public static XrEyeTrackerHTC operator *(XrEyeTrackerHTC a, XrEyeTrackerHTC b) { return a.value * b.value; }
+        public static XrEyeTrackerHTC operator /(XrEyeTrackerHTC a, XrEyeTrackerHTC b)
+        {
+            if (b.value == 0)
+            {
+                throw new DivideByZeroException();
+            }
+            return a.value / b.value;
+        }
+    }
+    /// <summary>
+    /// The XrEyePositionHTC describes which eye is under tracking for the data retrieved from <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see>, <see cref="XrEyePupilDataHTC">XrEyePupilDataHTC</see> or <see cref="XrEyeGeometricDataHTC">XrEyeGeometricDataHTC</see>.
+    /// </summary>
+    public enum XrEyePositionHTC
+    {
+        /// <summary>
+        /// Specifies the position of the left eye.
+        /// </summary>
+        XR_EYE_POSITION_LEFT_HTC = 0,
+        /// <summary>
+        /// Specifies the position of the right eye.
+        /// </summary>
+        XR_EYE_POSITION_RIGHT_HTC = 1,
+        XR_EYE_POSITION_COUNT_HTC = 2
+    };
+
+    /// <summary>
+    /// An application can inspect whether the system is capable of eye tracking input by extending the  <see cref="XrSystemProperties">XrSystemProperties</see> with  <see cref="XrSystemEyeTrackingPropertiesHTC">XrSystemEyeTrackingPropertiesHTC</see> structure when calling <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrSystemEyeTrackingPropertiesHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// Indicating if the current system is capable of receiving eye tracking input.
+        /// </summary>
+        public XrBool32 supportsEyeTracking;
+    };
+
+    /// <summary>
+    /// The XrEyeTrackerCreateInfoHTC structure describes the information to create an <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyeTrackerCreateInfoHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+
+        /// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        public XrEyeTrackerCreateInfoHTC(XrStructureType in_type, IntPtr in_next)
+        {
+            type = in_type;
+            next = in_next;
+        }
+    };
+
+    /// <summary>
+    /// The XrEyeGazeDataInfoHTC structure describes the information to get eye gaze directions.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyeGazeDataInfoHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// An <see cref="XrSpace">XrSpace</see> within which the returned eye poses will be represented.
+        /// </summary>
+        public XrSpace baseSpace;
+        /// <summary>
+        /// An <see cref="XrTime">XrTime</see> at which the eye gaze information is requested.
+        /// </summary>
+        public XrTime time;
+
+        /// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        /// <param name="in_baseSpace">An <see cref="XrSpace">XrSpace</see> within which the returned eye poses will be represented.</param>
+        /// <param name="in_time">An <see cref="XrTime">XrTime</see> at which the eye gaze information is requested.</param>
+        public XrEyeGazeDataInfoHTC(XrStructureType in_type, IntPtr in_next, XrSpace in_baseSpace, XrTime in_time)
+        {
+            type = in_type;
+            next = in_next;
+            baseSpace = in_baseSpace;
+            time = in_time;
+        }
+    };
+
+    /// <summary>
+    /// The XrSingleEyeGazeDataHTC structure describes the validity and direction of a eye gaze observation.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrSingleEyeGazeDataHTC
+    {
+        /// <summary>
+        /// An <see cref="XrBool32">XrBool32</see> indicating if the returned gazePose is valid. Callers should check the validity of pose prior to use.
+        /// </summary>
+        public XrBool32 isValid;
+        /// <summary>
+        /// An <see cref="XrPosef">XrPosef</see> describing the position and orientation of the user's eye. The pose is represented in the coordinate system provided by <see cref="XrEyeGazeDataInfoHTC">XrEyeGazeDataInfoHTC</see>::<see cref="XrEyeGazeDataInfoHTC.baseSpace">baseSpace</see>.
+        /// </summary>
+        public XrPosef gazePose;
+
+        /// <param name="in_isValid">An <see cref="XrBool32">XrBool32</see> indicating if the returned gazePose is valid. Callers should check the validity of pose prior to use.</param>
+        /// <param name="in_gazePose">An <see cref="XrPosef">XrPosef</see> describing the position and orientation of the user's eye. The pose is represented in the coordinate system provided by <see cref="XrEyeGazeDataInfoHTC">XrEyeGazeDataInfoHTC</see>::<see cref="XrEyeGazeDataInfoHTC.baseSpace">baseSpace</see>.</param>
+        public XrSingleEyeGazeDataHTC(XrBool32 in_isValid, XrPosef in_gazePose)
+        {
+            isValid = in_isValid;
+            gazePose = in_gazePose;
+        }
+    };
+
+    /// <summary>
+    /// The XrEyeGazeDataHTC structure returns the state of the eye gaze directions.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyeGazeDataHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// An <see cref="XrTime">XrTime</see> at which the eye gaze information is requested.
+        /// </summary>
+        public XrTime time;
+        /// <summary>
+        /// An array of <see cref="XrSingleEyeGazeDataHTC">XrSingleEyeGazeDataHTC</see> receiving the returned eye gaze directions.
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+        public XrSingleEyeGazeDataHTC[] gaze;
+    };
+
+    /// <summary>
+    /// The XrEyePupilDataInfoHTC structure describes the information to get pupil data.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyePupilDataInfoHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        public XrEyePupilDataInfoHTC(XrStructureType in_type, IntPtr in_next)
+        {
+            type = in_type;
+            next = in_next;
+        }
+    };
+
+    /// <summary>
+    /// The XrSingleEyePupilDataHTC structure describes the validity, diameter and position of a pupil observation.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrSingleEyePupilDataHTC
+    {
+        /// <summary>
+        /// An <see cref="XrBool32">XrBool32</see> indicating if the returned pupilDiameter is valid. Callers should check the validity of diameter prior to use.
+        /// </summary>
+        public XrBool32 isDiameterValid;
+        /// <summary>
+        /// An <see cref="XrBool32">XrBool32</see> indicating if the returned pupilPosition is valid. Callers should check the validity of position prior to use.
+        /// </summary>
+        public XrBool32 isPositionValid;
+        /// <summary>
+        /// The diameter of pupil in millimeters.
+        /// </summary>
+        public float pupilDiameter;
+        /// <summary>
+        /// The position of pupil in sensor area which x and y are normalized in [0,1] with +Y up and +X to the right.
+        /// </summary>
+        public XrVector2f pupilPosition;
+
+        /// <param name="in_isDiameterValid">An <see cref="XrBool32">XrBool32</see> indicating if the returned gazePose is valid. Callers should check the validity of pose prior to use.</param>
+        /// <param name="in_isPositionValid">An <see cref="XrBool32">XrBool32</see> indicating if the returned pupilPosition is valid. Callers should check the validity of position prior to use.</param>
+        /// <param name="in_pupilDiameter">The diameter of pupil in millimeters.</param>
+        /// <param name="in_pupilPosition">The position of pupil in sensor area which x and y are normalized in [0,1]with +Y up and +X to the right.</param>
+        public XrSingleEyePupilDataHTC(XrBool32 in_isDiameterValid, XrBool32 in_isPositionValid, float in_pupilDiameter, XrVector2f in_pupilPosition)
+        {
+            isDiameterValid = in_isDiameterValid;
+            isPositionValid = in_isPositionValid;
+            pupilDiameter  = in_pupilDiameter;
+            pupilPosition  = in_pupilPosition;
+        }
+    };
+
+    /// <summary>
+    /// The XrEyePupilDataHTC structure returns the pupil data.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyePupilDataHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// An <see cref="XrTime">XrTime</see> at which the pupil data was captured.
+        /// </summary>
+        public XrTime time;
+        /// <summary>
+        /// An array of <see cref="XrSingleEyePupilDataHTC">XrSingleEyePupilDataHTC</see> receiving the returned pupil data.
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+        public XrSingleEyePupilDataHTC[] pupilData;
+    };
+
+    /// <summary>
+    /// The XrEyeGeometricDataInfoHTC structure describes the information to get geometric related data.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyeGeometricDataInfoHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        public XrEyeGeometricDataInfoHTC(XrStructureType in_type, IntPtr in_next)
+        {
+            type = in_type;
+            next = in_next;
+        }
+    };
+
+    /// <summary>
+    /// The XrSingleEyeGeometricDataHTC structure describes the geometric related data.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrSingleEyeGeometricDataHTC
+    {
+        /// <summary>
+        /// A flag that indicates if the geometric data is valid. Callers should check the validity of the geometric data prior to use.
+        /// </summary>
+        public XrBool32 isValid;
+        /// <summary>
+        /// A value in range [0,1] representing the openness of the user's eye. When this value is zero, the eye closes normally. When this value is one, the eye opens normally. When this value goes higher, the eye approaches open.
+        /// </summary>
+        public float eyeOpenness;
+        /// <summary>
+        /// A value in range [0,1] representing how the user's eye open widely. When this value is zero, the eye opens normally. When this value goes higher, the eye opens wider.
+        public float eyeWide;
+        /// <summary>
+        /// A value in range [0,1] representing how the user's eye is closed. When this value is zero, the eye closes normally. When this value goes higher, the eye closes tighter.
+        /// </summary>
+        public float eyeSqueeze;
+
+        /// <param name="in_isValid">A flag that indicates if the geometric data is valid. Callers should check the validity of the geometric data prior to use.</param>
+        /// <param name="in_eyeOpenness">A value in range [0,1] representing the openness of the user's eye. When this value is zero, the eye closes normally. When this value is one, the eye opens normally. When this value goes higher, the eye approaches open.</param>
+        /// <param name="in_eyeWide">A value in range [0,1] representing how the user's eye open widely. When this value is zero, the eye opens normally. When this value goes higher, the eye opens wider.</param>
+        /// <param name="in_eyeSqueeze">A value in range [0,1] representing how the user's eye is closed. When this value is zero, the eye closes normally. When this value goes higher, the eye closes tighter.</param>
+        public XrSingleEyeGeometricDataHTC(XrBool32 in_isValid, float in_eyeOpenness, float in_eyeWide, float in_eyeSqueeze)
+        {
+            isValid = in_isValid;
+            eyeOpenness = in_eyeOpenness;
+            eyeWide = in_eyeWide;
+            eyeSqueeze = in_eyeSqueeze;
+        }
+    };
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrEyeGeometricDataHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// An <see cref="XrTime">XrTime</see> at which the returned eye data is tracked.
+        /// </summary>
+        public XrTime time;
+        /// <summary>
+        /// An array of <see cref="XrSingleEyeGeometricDataHTC">XrSingleEyeGeometricDataHTC</see> receiving the returned eye geometric data.
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+        public XrSingleEyeGeometricDataHTC[] eyeGeometricData;
+    };
+
+
+    public static class ViveEyeTrackerHelper
+    {
+        /// <param name="session">An XrSession in which the eye tracker will be active.</param>
+        /// <param name="createInfo">The <see cref="XrEyeTrackerCreateInfoHTC">XrEyeTrackerCreateInfoHTC</see> used to specify the eye tracker.</param>
+        /// <param name="eyeTracker">The returned <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrCreateEyeTrackerHTCDelegate(
+            XrSession session,
+            ref XrEyeTrackerCreateInfoHTC createInfo,
+            out XrEyeTrackerHTC eyeTracker);
+
+        /// <param name="eyeTracker">An XrEyeTrackerHTC previously created by xrCreateEyeTrackerHTC.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrDestroyEyeTrackerHTCDelegate(
+            XrEyeTrackerHTC 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="xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
+        /// <param name="gazeInfo">The information to get eye gaze.</param>
+        /// <param name="eyeGazes">A pointer to <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see> receiving the returned eye poses.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrGetEyeGazeDataHTCDelegate(
+            XrEyeTrackerHTC eyeTracker,
+            ref XrEyeGazeDataInfoHTC gazeInfo,
+            ref XrEyeGazeDataHTC eyeGazes);
+
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="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 delegate XrResult xrGetEyePupilDataHTCDelegate(
+            XrEyeTrackerHTC eyeTracker,
+            ref XrEyePupilDataInfoHTC pupilDataInfo,
+            ref XrEyePupilDataHTC pupilData);
+
+        /// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="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 delegate XrResult xrGetEyeGeometricDataHTC(
+            XrEyeTrackerHTC eyeTracker,
+            ref XrEyeGeometricDataInfoHTC info,
+            ref XrEyeGeometricDataHTC eyeGeometricData);
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9a5198e29bcef243bf89dc19b46ce0d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 918d2a03e014f5348b0f5fc5c6f7630c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 734a59e6cccf84f4f9407d01c4d88727
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Documentation/OpenXRExtensions.md

@@ -0,0 +1,87 @@
+# 12.68. XR_HTC_facial_tracking
+## Name String
+    XR_HTC_facial_tracking
+## Revision
+    1
+## Overview
+    This extension allows an application to track and integrate users' eye and lip movements, empowering developers to read intention and model facial expressions.
+
+## VIVE Plugin
+
+Through feeding the blend shape values of eye expression to an avatar, its facial expression can be animated with the player<65><72>s eye movement. The following enumerations show the facial expression of eye blend shape.
+
+    public enum XrEyeExpressionHTC
+    {
+        XR_EYE_EXPRESSION_LEFT_BLINK_HTC = 0,
+        XR_EYE_EXPRESSION_LEFT_WIDE_HTC = 1,
+        XR_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2,
+        XR_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3,
+        XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4,
+        XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5,
+        XR_EYE_EXPRESSION_LEFT_DOWN_HTC = 6,
+        XR_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7,
+        XR_EYE_EXPRESSION_LEFT_OUT_HTC = 8,
+        XR_EYE_EXPRESSION_RIGHT_IN_HTC = 9,
+        XR_EYE_EXPRESSION_LEFT_IN_HTC = 10,
+        XR_EYE_EXPRESSION_RIGHT_OUT_HTC = 11,
+        XR_EYE_EXPRESSION_LEFT_UP_HTC = 12,
+        XR_EYE_EXPRESSION_RIGHT_UP_HTC = 13,
+        XR_EYE_EXPRESSION_MAX_ENUM_HTC = 14
+    };
+
+You can use the following API to retrieve the array of eye expression values if the return value is true.
+
+    using VIVE.OpenXR.FacialTracking;
+    
+    bool ViveFacialTracking.GetFacialExpressions(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC, out float[] expressionWeightings);
+
+Through feeding the blend shape values of lip expression to an avatar, its facial expression can be animated with the player<65><72>s lip movement. The following enumerations show the facial expression of lip blend shape values.
+
+    public enum XrLipExpressionHTC
+    {
+        XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0,
+        XR_LIP_EXPRESSION_JAW_LEFT_HTC = 1,
+        XR_LIP_EXPRESSION_JAW_FORWARD_HTC = 2,
+        XR_LIP_EXPRESSION_JAW_OPEN_HTC = 3,
+        XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10,
+        XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11,
+        XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC = 12,
+        XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC = 13,
+        XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC = 14,
+        XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC = 15,
+        XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16,
+        XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17,
+        XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22,
+        XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24,
+        XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25,
+        XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26,
+        XR_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27,
+        XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28,
+        XR_LIP_EXPRESSION_TONGUE_UP_HTC = 29,
+        XR_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30,
+        XR_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31,
+        XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32,
+        XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33,
+        XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34,
+        XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35,
+        XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36,
+        XR_LIP_EXPRESSION_MAX_ENUM_HTC = 37
+    };
+
+You can use the following API to retrieve the array of eye expression values if the return value is true.
+
+    using VIVE.OpenXR.FacialTracking;
+    
+    bool ViveFacialTracking.GetFacialExpressions(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC, out float[] expressionWeightings);
+

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: be0ee5c3ad3e1b64590d426f9d79b274
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3aca591eccf98834c902458afd7c5bc0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Scripts/ViveFacialTracking.cs

@@ -0,0 +1,590 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine;
+using System.Runtime.InteropServices;
+using System;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.FacialTracking
+{
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Facial Tracking",
+        BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
+        Company = "HTC",
+        Desc = "Support the facial tracking extension.",
+        DocumentationLink = "..\\Documentation",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Version = "1.0.0",
+        FeatureId = featureId)]
+#endif
+    public class ViveFacialTracking : OpenXRFeature
+	{
+        const string LOG_TAG = "VIVE.OpenXR.FacialTracking.ViveFacialTracking";
+        void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+        void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+        void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+        /// <summary>
+        /// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking">12.68. XR_HTC_facial_tracking</see>.
+        /// </summary>
+        public const string kOpenxrExtensionString = "XR_HTC_facial_tracking";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.facial.tracking";
+
+        #region OpenXR Life Cycle
+        private bool m_XrInstanceCreated = false;
+        private XrInstance m_XrInstance = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The created instance.</param>
+        /// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+            {
+                WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+                return false;
+            }
+
+            m_XrInstanceCreated = true;
+            m_XrInstance = xrInstance;
+            DEBUG("OnInstanceCreate() " + m_XrInstance);
+
+            return GetXrFunctionDelegates(m_XrInstance);
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyInstance">xrDestroyInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The instance to destroy.</param>
+        protected override void OnInstanceDestroy(ulong xrInstance)
+        {
+            if (m_XrInstance == xrInstance)
+            {
+                m_XrInstanceCreated = false;
+                m_XrInstance = 0;
+            }
+            DEBUG("OnInstanceDestroy() " + xrInstance);
+        }
+
+        private XrSystemId m_XrSystemId = 0;
+        /// <summary>
+        /// Called when the <see cref="XrSystemId">XrSystemId</see> retrieved by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystem">xrGetSystem</see> is changed.
+        /// </summary>
+        /// <param name="xrSystem">The system id.</param>
+        protected override void OnSystemChange(ulong xrSystem)
+        {
+            m_XrSystemId = xrSystem;
+            DEBUG("OnSystemChange() " + m_XrSystemId);
+        }
+
+        private bool m_XrSessionCreated = false;
+        private XrSession m_XrSession = 0;
+        private bool hasEyeTracker = false, hasLipTracker = false;
+        private XrFacialTrackerHTC m_EyeTracker = 0, m_LipTracker = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateSession">xrCreateSession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The created session ID.</param>
+        protected override void OnSessionCreate(ulong xrSession)
+        {
+            m_XrSession = xrSession;
+            m_XrSessionCreated = true;
+            DEBUG("OnSessionCreate() " + m_XrSession);
+
+            if (CreateFacialTracker(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC)) { DEBUG("OnSessionCreate() m_EyeTracker " + m_EyeTracker); }
+            if (CreateFacialTracker(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC)) { DEBUG("OnSessionCreate() m_LipTracker " + m_LipTracker); }
+        }
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroySession">xrDestroySession</see> is done.
+        /// </summary>
+        /// <param name="xrSession">The session ID to destroy.</param>
+        protected override void OnSessionDestroy(ulong xrSession)
+        {
+            DEBUG("OnSessionDestroy() " + xrSession);
+
+            // Facial Tracking is binding with xrSession so we destroy the trackers when xrSession is destroyed.
+            DestroyFacialTracker(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC);
+            DestroyFacialTracker(XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC);
+
+            m_XrSession = 0;
+            m_XrSessionCreated = false;
+        }
+        #endregion
+
+        #region OpenXR function delegates
+        /// xrGetInstanceProcAddr
+        OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+
+        /// xrGetSystemProperties
+        OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
+        private XrResult GetSystemProperties(ref XrSystemProperties properties)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetSystemProperties() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetSystemProperties() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
+        }
+
+        /// xrDestroySpace
+        OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
+        private XrResult DestroySpace(XrSpace space)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("DestroySpace() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("DestroySpace() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrDestroySpace(space);
+        }
+
+        ViveFacialTrackingHelper.xrCreateFacialTrackerHTCDelegate xrCreateFacialTrackerHTC;
+        private XrResult CreateFacialTrackerHTC(XrFacialTrackerCreateInfoHTC createInfo, out XrFacialTrackerHTC facialTracker)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("CreateFacialTrackerHTC() XR_ERROR_SESSION_LOST.");
+                facialTracker = 0;
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+			{
+                ERROR("CreateFacialTrackerHTC() XR_ERROR_INSTANCE_LOST.");
+                facialTracker = 0;
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrCreateFacialTrackerHTC(m_XrSession, createInfo, out facialTracker);
+        }
+
+        ViveFacialTrackingHelper.xrDestroyFacialTrackerHTCDelegate xrDestroyFacialTrackerHTC;
+        private XrResult DestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("DestroyFacialTrackerHTC() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("DestroyFacialTrackerHTC() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrDestroyFacialTrackerHTC(facialTracker);
+        }
+
+        ViveFacialTrackingHelper.xrGetFacialExpressionsHTCDelegate xrGetFacialExpressionsHTC;
+        private XrResult GetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, ref XrFacialExpressionsHTC facialExpressions)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("GetFacialExpressionsHTC() XR_ERROR_SESSION_LOST.");
+                return XrResult.XR_ERROR_SESSION_LOST;
+            }
+            if (!m_XrInstanceCreated)
+            {
+                ERROR("GetFacialExpressionsHTC() XR_ERROR_INSTANCE_LOST.");
+                return XrResult.XR_ERROR_INSTANCE_LOST;
+            }
+
+            return xrGetFacialExpressionsHTC(facialTracker, ref facialExpressions);
+        }
+
+        private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            /// xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                DEBUG("Get function pointer of xrGetInstanceProcAddr.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                    xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+            }
+            else
+            {
+                ERROR("xrGetInstanceProcAddr");
+                return false;
+            }
+
+            IntPtr funcPtr = IntPtr.Zero;
+            /// xrGetSystemProperties
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetSystemProperties.");
+                    xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetSystemProperties");
+                return false;
+            }
+            /// xrDestroySpace
+            if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrDestroySpace.");
+                    xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrDestroySpace");
+                return false;
+            }
+
+            /// xrCreateFacialTrackerHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrCreateFacialTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrCreateFacialTrackerHTC.");
+                    xrCreateFacialTrackerHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveFacialTrackingHelper.xrCreateFacialTrackerHTCDelegate)) as ViveFacialTrackingHelper.xrCreateFacialTrackerHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrCreateFacialTrackerHTC");
+                return false;
+            }
+            /// xrDestroyFacialTrackerHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrDestroyFacialTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrDestroyFacialTrackerHTC.");
+                    xrDestroyFacialTrackerHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveFacialTrackingHelper.xrDestroyFacialTrackerHTCDelegate)) as ViveFacialTrackingHelper.xrDestroyFacialTrackerHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrDestroyFacialTrackerHTC");
+                return false;
+            }
+            /// xrGetFacialExpressionsHTC
+            if (XrGetInstanceProcAddr(xrInstance, "xrGetFacialExpressionsHTC", out funcPtr) == XrResult.XR_SUCCESS)
+            {
+                if (funcPtr != IntPtr.Zero)
+                {
+                    DEBUG("Get function pointer of xrGetFacialExpressionsHTC.");
+                    xrGetFacialExpressionsHTC = Marshal.GetDelegateForFunctionPointer(
+                        funcPtr,
+                        typeof(ViveFacialTrackingHelper.xrGetFacialExpressionsHTCDelegate)) as ViveFacialTrackingHelper.xrGetFacialExpressionsHTCDelegate;
+                }
+            }
+            else
+            {
+                ERROR("xrGetFacialExpressionsHTC");
+                return false;
+            }
+
+            return true;
+        }
+        #endregion
+
+        XrSystemFacialTrackingPropertiesHTC facialTrackingSystemProperties;
+        XrSystemProperties systemProperties;
+        private bool IsFacialTrackingSupported(XrFacialTrackingTypeHTC facialTrackingType)
+        {
+            if (!m_XrSessionCreated)
+            {
+                ERROR("IsFacialTrackingSupported() session is not created.");
+                return false;
+            }
+
+            facialTrackingSystemProperties.type = XrStructureType.XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC;
+            systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
+            systemProperties.next = Marshal.AllocHGlobal(Marshal.SizeOf(facialTrackingSystemProperties));
+
+            long offset = 0;
+            if (IntPtr.Size == 4)
+                offset = systemProperties.next.ToInt32();
+            else
+                offset = systemProperties.next.ToInt64();
+
+            IntPtr sys_facial_tracking_prop_ptr = new IntPtr(offset);
+            Marshal.StructureToPtr(facialTrackingSystemProperties, sys_facial_tracking_prop_ptr, false);
+
+            if (GetSystemProperties(ref systemProperties) == XrResult.XR_SUCCESS)
+            {
+                if (IntPtr.Size == 4)
+                    offset = systemProperties.next.ToInt32();
+                else
+                    offset = systemProperties.next.ToInt64();
+
+                sys_facial_tracking_prop_ptr = new IntPtr(offset);
+                facialTrackingSystemProperties = (XrSystemFacialTrackingPropertiesHTC)Marshal.PtrToStructure(sys_facial_tracking_prop_ptr, typeof(XrSystemFacialTrackingPropertiesHTC));
+
+                DEBUG("IsFacialTrackingSupported() XrSystemFacialTrackingPropertiesHTC.supportEyeFacialTracking: "
+                    + facialTrackingSystemProperties.supportEyeFacialTracking
+                    + ", supportLipFacialTracking: "
+                    + facialTrackingSystemProperties.supportLipFacialTracking);
+
+                return (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC ?
+                    (facialTrackingSystemProperties.supportEyeFacialTracking > 0) : (facialTrackingSystemProperties.supportLipFacialTracking > 0));
+            }
+            else
+            {
+                ERROR("IsFacialTrackingSupported() GetSystemProperties failed.");
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// An application can create an <see cref="XrFacialTrackingTypeHTC">XrFacialTrackerHTC</see> handle using CreateFacialTracker.
+        /// </summary>
+        /// <param name="facialTrackingType">The XrFacialTrackingTypeHTC describes which type of tracking the <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> is using.</param>
+        /// <param name="facialTracker">The returned XrFacialTrackerHTC handle.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public XrResult CreateFacialTracker(XrFacialTrackerCreateInfoHTC createInfo, out XrFacialTrackerHTC facialTracker)
+        {
+            if (createInfo.facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC && hasEyeTracker)
+			{
+                facialTracker = m_EyeTracker;
+                DEBUG("CreateFacialTracker() m_EyeTracker: " + facialTracker + " already created before.");
+                return XrResult.XR_SUCCESS;
+			}
+
+            if (createInfo.facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC && hasLipTracker)
+			{
+                facialTracker = m_LipTracker;
+                DEBUG("CreateFacialTracker() m_LipTracker: " + facialTracker + " already created before.");
+                return XrResult.XR_SUCCESS;
+            }
+
+            if (!IsFacialTrackingSupported(createInfo.facialTrackingType))
+            {
+                ERROR("CreateFacialTracker() " + createInfo.facialTrackingType + " is NOT supported.");
+                facialTracker = 0;
+                return XrResult.XR_ERROR_VALIDATION_FAILURE;
+            }
+
+            var result = CreateFacialTrackerHTC(createInfo, out facialTracker);
+            DEBUG("CreateFacialTracker() " + createInfo.facialTrackingType + ", CreateFacialTrackerHTC = " + result + ", facialTracker: " + facialTracker);
+
+            if (result == XrResult.XR_SUCCESS)
+            {
+                if (createInfo.facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC)
+                {
+                    hasEyeTracker = true;
+                    m_EyeTracker = facialTracker;
+                    DEBUG("CreateFacialTracker() m_EyeTracker " + m_EyeTracker);
+                }
+                if (createInfo.facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC)
+				{
+                    hasLipTracker = true;
+                    m_LipTracker = facialTracker;
+                    DEBUG("CreateFacialTracker() m_LipTracker " + m_LipTracker);
+                }
+            }
+
+            return result;
+        }
+        /// <summary>
+        /// An application can create an <see cref="XrFacialTrackingTypeHTC">XrFacialTrackerHTC</see> handle using CreateFacialTracker.
+        /// </summary>
+        /// <param name="facialTrackingType">The XrFacialTrackingTypeHTC describes which type of tracking the <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> is using.</param>
+        /// <returns>True for success.</returns>
+        public bool CreateFacialTracker(XrFacialTrackingTypeHTC facialTrackingType)
+		{
+            XrFacialTrackerCreateInfoHTC createInfo = new XrFacialTrackerCreateInfoHTC(
+                in_type: XrStructureType.XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC,
+                in_next: IntPtr.Zero,
+                in_facialTrackingType: facialTrackingType);
+
+            var result = CreateFacialTracker(createInfo, out XrFacialTrackerHTC value);
+            DEBUG("CreateFacialTracker() " + createInfo.facialTrackingType + " tracker: " + value);
+
+            return result == XrResult.XR_SUCCESS;
+		}
+
+        /// <summary>
+        /// Releases the facial tracker and the underlying resources of the <see cref="XrFacialTrackingTypeHTC">facial tracking type</see> when finished with facial tracking experiences.
+        /// </summary>
+        /// <param name="facialTracker">Facial tracker in <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see>.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public XrResult DestroyFacialTracker(XrFacialTrackerHTC facialTracker)
+        {
+            XrResult result = DestroyFacialTrackerHTC(facialTracker);
+            DEBUG("DestroyFacialTracker() " + facialTracker + ", result: " + result);
+
+            return result;
+        }
+        /// <summary>
+        /// Releases the facial tracker and the underlying resources of the <see cref="XrFacialTrackingTypeHTC">facial tracking type</see> when finished with facial tracking experiences.
+        /// </summary>
+        /// <param name="facialTrackingType">The <see cref="XrFacialTrackingTypeHTC">XrFacialTrackingTypeHTC</see> describes which type of tracking the <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> is using.</param>
+        /// <returns>True for success.</returns>
+        public bool DestroyFacialTracker(XrFacialTrackingTypeHTC facialTrackingType)
+        {
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC && !hasEyeTracker)
+            {
+                DEBUG("DestroyFacialTracker() no " + facialTrackingType + "tracker.");
+                return true;
+            }
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC && !hasLipTracker)
+            {
+                DEBUG("DestroyFacialTracker() no " + facialTrackingType + "tracker.");
+                return true;
+            }
+
+            XrResult ret = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC)
+            {
+                ret = DestroyFacialTracker(m_EyeTracker);
+                hasEyeTracker = false;
+                m_EyeTracker = 0;
+            }
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC)
+            {
+                ret = DestroyFacialTracker(m_LipTracker);
+                hasLipTracker = false;
+                m_LipTracker = 0;
+            }
+
+            return ret == XrResult.XR_SUCCESS;
+        }
+
+        private int eyeUpdateFrame = -1, lipUpdateFrame = -1;
+        private float[] defExpressionData = new float[(int)XrEyeExpressionHTC.XR_EYE_EXPRESSION_MAX_ENUM_HTC];
+        private float[] s_EyeExpressionData = new float[(int)XrEyeExpressionHTC.XR_EYE_EXPRESSION_MAX_ENUM_HTC];
+        private float[] s_LipExpressionData = new float[(int)XrLipExpressionHTC.XR_LIP_EXPRESSION_MAX_ENUM_HTC];
+        XrFacialExpressionsHTC facialExpressionsDef = new XrFacialExpressionsHTC(XrStructureType.XR_TYPE_FACIAL_EXPRESSIONS_HTC, IntPtr.Zero, false, 0, 0, IntPtr.Zero);
+        XrFacialExpressionsHTC m_FacialExpressionsEye = new XrFacialExpressionsHTC(XrStructureType.XR_TYPE_FACIAL_EXPRESSIONS_HTC, IntPtr.Zero, false, 0, 0, IntPtr.Zero);
+        XrFacialExpressionsHTC m_FacialExpressionsLip = new XrFacialExpressionsHTC(XrStructureType.XR_TYPE_FACIAL_EXPRESSIONS_HTC, IntPtr.Zero, false, 0, 0, IntPtr.Zero);
+        /// <summary>
+        /// Retrieves an array of values of blend shapes for a facial expression on a given time.
+        /// </summary>
+        /// <param name="facialTrackingType">The <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackingTypeHTC">XrFacialTrackingTypeHTC</see> describes which type of tracking the <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> is using.</param>
+        /// <param name="expressionWeightings">A float array filled in by the runtime, specifying the weightings for each blend shape. The array size is <see cref="XrEyeExpressionHTC.XR_EYE_EXPRESSION_MAX_ENUM_HTC">XR_EYE_EXPRESSION_MAX_ENUM_HTC</see> for eye expression and <see cref="XrLipExpressionHTC.XR_LIP_EXPRESSION_MAX_ENUM_HTC">XR_LIP_EXPRESSION_MAX_ENUM_HTC</see> for lip expression.</param>
+        /// <returns>True for success.</returns>
+        public bool GetFacialExpressions(XrFacialTrackingTypeHTC facialTrackingType, out float[] expressionWeightings)
+		{
+            expressionWeightings = defExpressionData;
+
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC)
+            {
+                if (GetFacialExpressions(m_EyeTracker, out XrFacialExpressionsHTC facialExpressions) == XrResult.XR_SUCCESS)
+                {
+                    if (facialExpressions.isActive)
+                    {
+                        Marshal.Copy(facialExpressions.expressionWeightings, s_EyeExpressionData, 0, (int)facialExpressions.expressionCount);
+                        expressionWeightings = s_EyeExpressionData;
+                        return true;
+                    }
+                }
+            }
+            if (facialTrackingType == XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC)
+            {
+                if (GetFacialExpressions(m_LipTracker, out XrFacialExpressionsHTC facialExpressions) == XrResult.XR_SUCCESS)
+                {
+                    if (facialExpressions.isActive)
+                    {
+                        Marshal.Copy(facialExpressions.expressionWeightings, s_LipExpressionData, 0, (int)facialExpressions.expressionCount);
+                        expressionWeightings = s_LipExpressionData;
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+        /// <summary>
+        /// Retrieves the <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrFacialExpressionsHTC">XrFacialExpressionsHTC</see> data of a <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerHTC">XrFacialTrackerHTC</see>.
+        /// </summary>
+        /// <param name="facialTracker">The <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerHTC">XrFacialTrackerHTC</see> handle represents the resources for an facial tracker of the specific facial tracking type.</param>
+        /// <param name="facialExpressions">Structure returns data of a lip facial expression or an eye facial expression.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public XrResult GetFacialExpressions(XrFacialTrackerHTC facialTracker, out XrFacialExpressionsHTC facialExpressions)
+        {
+            facialExpressions = facialExpressionsDef;
+            XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
+
+            if (facialTracker == m_EyeTracker)
+            {
+                if (eyeUpdateFrame == Time.frameCount)
+                {
+                    facialExpressions = m_FacialExpressionsEye;
+                    return XrResult.XR_SUCCESS;
+                }
+                eyeUpdateFrame = Time.frameCount;
+
+                // Initialize the XrFacialExpressionsHTC struct of Eye.
+                if (m_FacialExpressionsEye.expressionCount == 0)
+				{
+                    m_FacialExpressionsEye.type = XrStructureType.XR_TYPE_FACIAL_EXPRESSIONS_HTC;
+                    m_FacialExpressionsEye.next = IntPtr.Zero;
+                    m_FacialExpressionsEye.isActive = false;
+                    m_FacialExpressionsEye.sampleTime = 0;
+                    m_FacialExpressionsEye.expressionCount = (UInt32)XrEyeExpressionHTC.XR_EYE_EXPRESSION_MAX_ENUM_HTC;
+                    m_FacialExpressionsEye.expressionWeightings = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * (int)m_FacialExpressionsEye.expressionCount);
+                }
+
+                result = GetFacialExpressionsHTC(facialTracker, ref m_FacialExpressionsEye);
+                if (result == XrResult.XR_SUCCESS) { facialExpressions = m_FacialExpressionsEye; }
+            }
+            if (facialTracker == m_LipTracker)
+            {
+                if (lipUpdateFrame == Time.frameCount)
+                {
+                    facialExpressions = m_FacialExpressionsLip;
+                    return XrResult.XR_SUCCESS;
+                }
+                lipUpdateFrame = Time.frameCount;
+
+                // Initialize the XrFacialExpressionsHTC struct of Lip.
+                if (m_FacialExpressionsLip.expressionCount == 0)
+				{
+                    m_FacialExpressionsLip.type = XrStructureType.XR_TYPE_FACIAL_EXPRESSIONS_HTC;
+                    m_FacialExpressionsLip.next = IntPtr.Zero;
+                    m_FacialExpressionsLip.isActive = false;
+                    m_FacialExpressionsLip.sampleTime = 0;
+                    m_FacialExpressionsLip.expressionCount = (UInt32)XrLipExpressionHTC.XR_LIP_EXPRESSION_MAX_ENUM_HTC;
+                    m_FacialExpressionsLip.expressionWeightings = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * (int)m_FacialExpressionsLip.expressionCount);
+                }
+
+                result = GetFacialExpressionsHTC(facialTracker, ref m_FacialExpressionsLip);
+                if (result == XrResult.XR_SUCCESS) { facialExpressions = m_FacialExpressionsLip; }
+            }
+
+            return result;
+        }
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Scripts/ViveFacialTracking.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 178a55074d1e6624d8cfbdc23367a56f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Scripts/ViveFacialTrackingHelper.cs

@@ -0,0 +1,441 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace VIVE.OpenXR.FacialTracking
+{
+    /// <summary>
+    /// The XrFacialTrackerHTC handle represents the resources for an facial tracker of the specific facial tracking type.
+    /// </summary>
+    public struct XrFacialTrackerHTC : IEquatable<UInt64>
+    {
+        private readonly UInt64 value;
+
+        public XrFacialTrackerHTC(UInt64 u)
+        {
+            value = u;
+        }
+
+        public static implicit operator UInt64(XrFacialTrackerHTC equatable)
+        {
+            return equatable.value;
+        }
+        public static implicit operator XrFacialTrackerHTC(UInt64 u)
+        {
+            return new XrFacialTrackerHTC(u);
+        }
+
+        public bool Equals(XrFacialTrackerHTC other)
+        {
+            return value == other.value;
+        }
+        public bool Equals(UInt64 other)
+        {
+            return value == other;
+        }
+        public override bool Equals(object obj)
+        {
+            return obj is XrFacialTrackerHTC && Equals((XrFacialTrackerHTC)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return value.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return value.ToString();
+        }
+
+        public static bool operator ==(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.Equals(b); }
+        public static bool operator !=(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return !a.Equals(b); }
+        public static bool operator >=(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value >= b.value; }
+        public static bool operator <=(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value <= b.value; }
+        public static bool operator >(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value > b.value; }
+        public static bool operator <(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value < b.value; }
+        public static XrFacialTrackerHTC operator +(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value + b.value; }
+        public static XrFacialTrackerHTC operator -(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value - b.value; }
+        public static XrFacialTrackerHTC operator *(XrFacialTrackerHTC a, XrFacialTrackerHTC b) { return a.value * b.value; }
+        public static XrFacialTrackerHTC operator /(XrFacialTrackerHTC a, XrFacialTrackerHTC b)
+        {
+            if (b.value == 0)
+            {
+                throw new DivideByZeroException();
+            }
+            return a.value / b.value;
+        }
+
+    }
+    /// <summary>
+    /// The XrFacialTrackingTypeHTC describes which type of tracking the <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> is using.
+    /// </summary>
+    public enum XrFacialTrackingTypeHTC
+    {
+        /// <summary>
+        /// Specifies this handle will observe eye expressions, with values indexed by <see cref="XrEyeExpressionHTC">XrEyeExpressionHTC</see> whose count is <see cref="ViveFacialTrackingHelper.XR_FACIAL_EXPRESSION_EYE_COUNT_HTC">XR_FACIAL_EXPRESSION_EYE_COUNT_HTC</see>.
+        /// </summary>
+        XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1,
+        /// <summary>
+        /// Specifies this handle will observe lip expressions, with values indexed by <see cref="XrLipExpressionHTC">XrLipExpressionHTC</see> whose count is <see cref="ViveFacialTrackingHelper.XR_FACIAL_EXPRESSION_LIP_COUNT_HTC">XR_FACIAL_EXPRESSION_LIP_COUNT_HTC</see>.
+        /// </summary>
+        XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC = 2,
+    };
+    /// <summary>
+    /// Indicates the eye expressions. Refer to <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrEyeExpressionHTC">XrEyeExpressionHTC</see> about the illustrations. 
+    /// </summary>
+    public enum XrEyeExpressionHTC
+    {
+        /// <summary>
+        /// This blend shape influences blinking of the right eye. When this value goes higher, left eye approaches close.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_BLINK_HTC = 0,
+        /// <summary>
+        /// This blend shape keeps left eye wide and at that time XR_EYE_EXPRESSION_LEFT_BLINK_HTC value is 0.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_WIDE_HTC = 1,
+        /// <summary>
+        /// This blend shape influences blinking of the right eye. When this value goes higher, right eye approaches close.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2,
+        /// <summary>
+        /// This blend shape keeps right eye wide and at that time XR_EYE_EXPRESSION_RIGHT_BLINK_HTC value is 0.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3,
+        /// <summary>
+        /// The blend shape closes eye tightly and at that time XR_EYE_EXPRESSION_LEFT_BLINK_HTC value is 1.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4,
+        /// <summary>
+        /// The blend shape closes eye tightly and at that time XR_EYE_EXPRESSION_RIGHT_BLINK_HTC value is 1.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5,
+        /// <summary>
+        /// This blendShape influences the muscles around the left eye, moving these muscles further downward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_DOWN_HTC = 6,
+        /// <summary>
+        /// This blendShape influences the muscles around the right eye, moving these muscles further downward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7,
+        /// <summary>
+        /// This blendShape influences the muscles around the left eye, moving these muscles further leftward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_OUT_HTC = 8,
+        /// <summary>
+        /// This blendShape influences the muscles around the right eye, moving these muscles further leftward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_IN_HTC = 9,
+        /// <summary>
+        /// This blendShape influences the muscles around the left eye, moving these muscles further rightward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_IN_HTC = 10,
+        /// <summary>
+        /// This blendShape influences the muscles around the right eye, moving these muscles further rightward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_OUT_HTC = 11,
+        /// <summary>
+        /// This blendShape influences the muscles around the left eye, moving these muscles further upward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_LEFT_UP_HTC = 12,
+        /// <summary>
+        /// This blendShape influences the muscles around the right eye, moving these muscles further upward with a higher value.
+        /// </summary>
+        XR_EYE_EXPRESSION_RIGHT_UP_HTC = 13,
+        XR_EYE_EXPRESSION_MAX_ENUM_HTC = 14
+    };
+    /// <summary>
+    /// Indicates the lip expressions. Refer to <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrLipExpressionHTC">XrLipExpressionHTC</see> about the illustrations.
+    /// </summary>
+    public enum XrLipExpressionHTC
+    {
+        /// <summary>
+        /// This blend shape moves the jaw further rightward with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0,
+        /// <summary>
+        /// This blend shape moves the jaw further leftward with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_JAW_LEFT_HTC = 1,
+        /// <summary>
+        /// This blend shape moves the jaw forward with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_JAW_FORWARD_HTC = 2,
+        /// <summary>
+        /// This blend shape opens the mouth further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_JAW_OPEN_HTC = 3,
+        /// <summary>
+        /// This blend shape stretches the jaw further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4,
+        /// <summary>
+        /// This blend shape moves your upper lip rightward.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5,
+        /// <summary>
+        /// This blend shape moves your upper lip leftward.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6,
+        /// <summary>
+        /// This blend shape moves your lower lip rightward.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7,
+        /// <summary>
+        /// This blend shape moves your lower lip leftward.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8,
+        /// <summary>
+        /// This blend shape pouts your upper lip. Can be used with <see cref="XrLipExpressionHTC.XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC">XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC</see> and <see cref="XrLipExpressionHTC.XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC">XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC</see> to complete upper O mouth shape.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9,
+        /// <summary>
+        /// This blend shape pouts your lower lip. Can be used with <see cref="XrLipExpressionHTC.XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC">XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC</see> and <see cref="XrLipExpressionHTC.XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC">XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC</see> to complete upper O mouth shape.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10,
+        /// <summary>
+        /// This blend shape allows the lips to pout more with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11,
+        /// <summary>
+        /// This blend shape raises the right side of the mouth further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC = 12,
+        /// <summary>
+        /// This blend shape raises the left side of the mouth further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC = 13,
+        /// <summary>
+        /// This blend shape lowers the right side of the mouth further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC = 14,
+        /// <summary>
+        /// This blend shape lowers the left side of the mouth further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC = 15,
+        /// <summary>
+        /// This blend shape puffs up the right side of the cheek further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16,
+        /// <summary>
+        /// This blend shape puffs up the left side of the cheek further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17,
+        /// <summary>
+        /// This blend shape sucks in the cheeks on both sides further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18,
+        /// <summary>
+        /// This blend shape raises the right upper lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19,
+        /// <summary>
+        /// This blend shape raises the left upper lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20,
+        /// <summary>
+        /// This blend shape lowers the right lower lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21,
+        /// <summary>
+        /// This blend shape lowers the left lower lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22,
+        /// <summary>
+        /// This blend shape rolls in the upper lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23,
+        /// <summary>
+        /// This blend shape rolls in the lower lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24,
+        /// <summary>
+        /// This blend shape stretches the lower lip further and lays it on the upper lip further with a higher value.
+        /// </summary>
+        XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25,
+        /// <summary>
+        /// This blend shape sticks the tongue out slightly.
+        /// 
+        /// In step 1 of extending the tongue, the main action of the tongue is to lift up, and the elongated length only extends to a little bit beyond the teeth.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26,
+        /// <summary>
+        /// This blend shape sticks the tongue out and left extremely.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27,
+        /// <summary>
+        /// This blend shape sticks the tongue out and right extremely.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28,
+        /// <summary>
+        /// This blend shape sticks the tongue out and up extremely.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_UP_HTC = 29,
+        /// <summary>
+        /// This blend shape sticks the tongue out and down extremely.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30,
+        /// <summary>
+        /// This blend shape sticks the tongue out with roll type.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31,
+        /// <summary>
+        /// This blend shape sticks the tongue out extremely.
+        /// 
+        /// Continuing the step 1, it extends the tongue to the longest.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32,
+        /// <summary>
+        /// This blend shape doesn’t make sense. When both the right and up blend shapes appear at the same time, the tongue will be deformed.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33,
+        /// <summary>
+        /// This blend shape doesn’t make sense. When both the left and up blend shapes appear at the same time, the tongue will be deformed.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34,
+        /// <summary>
+        /// This blend shape doesn’t make sense. When both the right and down blend shapes appear at the same time, the tongue will be deformed.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35,
+        /// <summary>
+        /// This blend shape doesn’t make sense. When both the left and down blend shapes appear at the same time, the tongue will be deformed.
+        /// </summary>
+        XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36,
+        XR_LIP_EXPRESSION_MAX_ENUM_HTC = 37
+    };
+
+    /// <summary>
+    /// An application can inspect whether the system is capable of two of the facial tracking by extending the <see cref="XrSystemProperties">XrSystemProperties</see> with <see cref="XrSystemFacialTrackingPropertiesHTC">XrSystemFacialTrackingPropertiesHTC</see> structure when calling <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrSystemFacialTrackingPropertiesHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// Indicates if the current system is capable of generating eye expressions.
+        /// </summary>
+        public XrBool32 supportEyeFacialTracking;
+        /// <summary>
+        /// Indicates if the current system is capable of generating lip expressions.
+        /// </summary>
+        public XrBool32 supportLipFacialTracking;
+    };
+
+    /// <summary>
+    /// The XrFacialTrackerCreateInfoHTC structure describes the information to create an <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> handle.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrFacialTrackerCreateInfoHTC
+    {
+        /// <summary>
+        /// The <see cref="XrStructureType">XrStructureType</see> of this structure.
+        /// </summary>
+        public XrStructureType type;
+        /// <summary>
+        /// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+        /// </summary>
+        public IntPtr next;
+        /// <summary>
+        /// An XrFacialTrackingTypeHTC which describes which type of facial tracking should be used for this handle.
+        /// </summary>
+        public XrFacialTrackingTypeHTC facialTrackingType;
+
+        /// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        /// <param name="in_facialTrackingType">An XrFacialTrackingTypeHTC which describes which type of facial tracking should be used for this handle.</param>
+        public XrFacialTrackerCreateInfoHTC(XrStructureType in_type, IntPtr in_next, XrFacialTrackingTypeHTC in_facialTrackingType)
+        {
+            type = in_type;
+            next = in_next;
+            facialTrackingType = in_facialTrackingType;
+        }
+    };
+
+    /// <summary>
+    /// XrFacialExpressionsHTC structure returns data of a lip facial expression or an eye facial expression.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct XrFacialExpressionsHTC
+    {
+        /// <summary>The XrStructureType of this structure.</summary>
+        public XrStructureType type;
+        /// <summary>NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</summary>
+        public IntPtr next;
+        /// <summary>An XrBool32 indicating if the facial tracker is active.</summary>
+        public XrBool32 isActive;
+        /// <summary>When in time the expression is expressed.</summary>
+        public XrTime sampleTime;
+        /// <summary>A uint32_t describing the count of elements in expressionWeightings array.</summary>
+        public UInt32 expressionCount;
+        /// <summary>A float array filled in by the runtime, specifying the weightings for each blend shape.</summary>
+        public IntPtr expressionWeightings;
+
+        /// <param name="in_type">The XrStructureType of this structure.</param>
+        /// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
+        /// <param name="in_isActive">An XrBool32 indicating if the facial tracker is active.</param>
+        /// <param name="in_sampleTime">When in time the expression is expressed.</param>
+        /// <param name="in_expressionCount">>A uint32_t describing the count of elements in expressionWeightings array.</param>
+        /// <param name="in_expressionWeightings">A float array filled in by the runtime, specifying the weightings for each blend shape.</param>
+        public XrFacialExpressionsHTC(
+            XrStructureType in_type,
+            IntPtr in_next,
+            XrBool32 in_isActive,
+            XrTime in_sampleTime,
+            UInt32 in_expressionCount,
+            IntPtr in_expressionWeightings)
+        {
+            type = in_type;
+            next = in_next;
+            isActive = in_isActive;
+            sampleTime = in_sampleTime;
+            expressionCount = in_expressionCount;
+            expressionWeightings = in_expressionWeightings;
+        }
+    };
+
+    public static class ViveFacialTrackingHelper
+    {
+        /// <summary> The number of blend shapes in an expression of type <see cref="XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC">XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC</see>. </summary>
+        public const UInt32 XR_FACIAL_EXPRESSION_EYE_COUNT_HTC = 14;
+        /// <summary> The number of blend shapes in an expression of type <see cref="XrFacialTrackingTypeHTC.XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC">XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC.</see> </summary>
+        public const UInt32 XR_FACIAL_EXPRESSION_LIP_COUNT_HTC = 37;
+
+        /// <summary>
+        /// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateFacialTrackerHTC">xrCreateFacialTrackerHTC</see>.
+        /// </summary>
+        /// <param name="session">An XrSession in which the facial expression will be active.</param>
+        /// <param name="createInfo">The <see cref="XrFacialTrackerCreateInfoHTC">XrFacialTrackerCreateInfoHTC</see> used to specify the facial tracking type.</param>
+        /// <param name="facialTracker">The returned <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> handle.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrCreateFacialTrackerHTCDelegate(
+            XrSession session,
+            XrFacialTrackerCreateInfoHTC createInfo,
+            out XrFacialTrackerHTC facialTracker);
+
+        /// <summary>
+        /// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyFacialTrackerHTC">xrDestroyFacialTrackerHTC</see>.
+        /// </summary>
+        /// <param name="facialTracker">An XrFacialTrackerHTC previously created by xrCreateFacialTrackerHTC.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrDestroyFacialTrackerHTCDelegate(
+            XrFacialTrackerHTC facialTracker);
+
+        /// <summary>
+        /// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetFacialExpressionsHTC">xrGetFacialExpressionsHTC</see>.
+        /// </summary>
+        /// <param name="facialTracker">An <see cref="XrFacialTrackerHTC">XrFacialTrackerHTC</see> previously created by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateFacialTrackerHTC">xrCreateFacialTrackerHTC</see>.</param>
+        /// <param name="facialExpressions">A pointer to <see cref="XrFacialExpressionsHTC">XrFacialExpressionsHTC</see> receiving the returned facial expressions.</param>
+        /// <returns>XR_SUCCESS for success.</returns>
+        public delegate XrResult xrGetFacialExpressionsHTCDelegate(
+            XrFacialTrackerHTC facialTracker,
+            ref XrFacialExpressionsHTC facialExpressions);
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/FacialTracking/Scripts/ViveFacialTrackingHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0ff2614ff91df1649bef349243f26eff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FirstPersonObserver.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6368702137725614d8d921ef6c1220f1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FirstPersonObserver/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e80a989be51974a4e88bdc41872d53c9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FirstPersonObserver/Scripts/ViveFirstPersonObserver.cs

@@ -0,0 +1,185 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+using VIVE.OpenXR.SecondaryViewConfiguration;
+
+namespace VIVE.OpenXR.FirstPersonObserver
+{
+    /// <summary>
+    /// Name: FirstPersonObserver.cs
+    /// Role: OpenXR FirstPersonObserver Extension Class 
+    /// Responsibility: The OpenXR extension implementation and its lifecycles logic in OpenXR
+    /// </summary>
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "XR MSFT First Person Observer",
+        BuildTargetGroups = new[] { BuildTargetGroup.Android },
+        Company = "HTC",
+        Desc = "Request the application to render an additional first-person view of the scene.",
+        DocumentationLink = "..\\Documentation",
+        OpenxrExtensionStrings = OPEN_XR_EXTENSION_STRING,
+        Version = "1.0.0",
+        FeatureId = FeatureId,
+        Hidden = true)]
+#endif
+    public class ViveFirstPersonObserver : OpenXRFeature
+    {
+        private static ViveFirstPersonObserver _instance;
+
+        /// <summary>
+        /// ViveFirstPersonObserver static instance (Singleton).
+        /// </summary>
+        public static ViveFirstPersonObserver Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance =
+                        OpenXRSettings.Instance.GetFeature<ViveFirstPersonObserver>();
+                }
+
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// The log identification.
+        /// </summary>
+        private const string LogTag = "VIVE.OpenXR.FirstPersonObserver";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>  
+        public const string FeatureId = "vive.openxr.feature.firstpersonobserver";
+
+        /// <summary>
+        /// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_first_person_observer">12.114. XR_MSFT_first_person_observer</see>.
+        /// </summary>
+        public const string OPEN_XR_EXTENSION_STRING = "XR_MSFT_first_person_observer";
+
+        /// <summary>
+        /// The flag represents whether the OpenXR loader created an instance or not.
+        /// </summary>
+        private bool XrInstanceCreated { get; set; } = false;
+
+        /// <summary>
+        /// The instance created through xrCreateInstance.
+        /// </summary>
+        private XrInstance XrInstance { get; set; } = 0;
+
+        /// <summary>
+        /// The function delegate declaration of xrGetInstanceProcAddr.
+        /// </summary>
+        private OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr { get; set; }
+
+        #region OpenXR life-cycle events
+
+        /// <summary>
+        /// Called after xrCreateInstance.
+        /// </summary>
+        /// <param name="xrInstance">Handle of the xrInstance.</param>
+        /// <returns>Returns true if successful. Returns false otherwise.</returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!IsExtensionEnabled())
+            {
+                Warning($"OnInstanceCreate() {OPEN_XR_EXTENSION_STRING} or " +
+                        $"{ViveSecondaryViewConfiguration.OPEN_XR_EXTENSION_STRING} is NOT enabled.");
+                return false;
+            }
+
+            XrInstanceCreated = true;
+            XrInstance = xrInstance;
+            Debug("OnInstanceCreate() " + XrInstance);
+
+            if (!GetXrFunctionDelegates(XrInstance))
+            {
+                Error("Get function pointer of OpenXRFunctionPointerAccessor failed.");
+                return false;
+            }
+
+            Debug("Get function pointer of OpenXRFunctionPointerAccessor succeed.");
+            return base.OnInstanceCreate(xrInstance);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Get the OpenXR function via XrInstance.
+        /// </summary>
+        /// <param name="xrInstance">The XrInstance is provided by the Unity OpenXR Plugin.</param>
+        /// <returns>Return true if get successfully. False otherwise.</returns>
+        private bool GetXrFunctionDelegates(XrInstance xrInstance)
+        {
+            if (xrGetInstanceProcAddr != IntPtr.Zero)
+            {
+                Debug("Get function pointer of openXRFunctionPointerAccessor.");
+                XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(xrGetInstanceProcAddr,
+                    typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+
+                if (XrGetInstanceProcAddr == null)
+                {
+                    Error(
+                        "Get function pointer of openXRFunctionPointerAccessor failed due to the XrGetInstanceProcAddr is null.");
+                    return false;
+                }
+            }
+            else
+            {
+                Error(
+                    "Get function pointer of openXRFunctionPointerAccessor failed due to the xrGetInstanceProcAddr is null.");
+                return false;
+            }
+
+            return true;
+        }
+
+        #region Utilities functions
+
+        /// <summary>
+        /// Check ViveFirstPersonObserver extension is enabled or not. 
+        /// </summary>
+        /// <returns>Return true if enabled. False otherwise.</returns>
+        public static bool IsExtensionEnabled()
+        {
+            return OpenXRRuntime.IsExtensionEnabled(OPEN_XR_EXTENSION_STRING) &&
+                   ViveSecondaryViewConfiguration.IsExtensionEnabled();
+        }
+
+        /// <summary>
+        /// Print log with tag "VIVE.OpenXR.SecondaryViewConfiguration".
+        /// </summary>
+        /// <param name="msg">The log you want to print.</param>
+        private static void Debug(string msg)
+        {
+            UnityEngine.Debug.Log(LogTag + " " + msg);
+        }
+
+        /// <summary>
+        /// Print warning message with tag "VIVE.OpenXR.SecondaryViewConfiguration".
+        /// </summary>
+        /// <param name="msg">The warning message you want to print.</param>
+        private static void Warning(string msg)
+        {
+            UnityEngine.Debug.LogWarning(LogTag + " " + msg);
+        }
+
+        /// <summary>
+        /// Print an error message with the tag "VIVE.OpenXR.SecondaryViewConfiguration."
+        /// </summary>
+        /// <param name="msg">The error message you want to print.</param>
+        private static void Error(string msg)
+        {
+            UnityEngine.Debug.LogError(LogTag + " " + msg);
+        }
+
+        #endregion
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/FirstPersonObserver/Scripts/ViveFirstPersonObserver.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 311462c0560d6ec4ea9ed080a6a77a3b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3ea80802b9699ba4099f42a28dafe7f9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7668e041703aef84793af8e9ed989023
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Documentation/OpenXRExtensions.md

@@ -0,0 +1,44 @@
+# 12.70. XR_HTC_vive_wrist_tracker_interaction
+## Name String
+    XR_HTC_vive_wrist_tracker_interaction
+## Revision
+    1
+## VIVE Wrist Tracker input
+### Interaction profile path:
+- /interaction_profiles/htc/vive_wrist_tracker
+
+### Valid for user paths:
+- /user/wrist_htc/left
+- /user/wrist_htc/right
+
+### Supported input source
+- On /user/wrist_htc/left only:
+  - <20>K/input/menu/click
+  - <20>K/input/x/click
+- On /user/wrist_htc/right only:
+  - <20>K/input/system/click (may not be available for application use) 
+  - <20>K/input/a/click
+- <20>K/input/entity_htc/pose
+
+The entity_htc pose allows the applications to recognize the origin of a tracked input device, especially for the wearable devices which are not held in the user<65><72>s hand. The entity_htc pose is defined as follows:
+
+- The entity position: The center position of the tracked device.
+- The entity orientation: Oriented with +Y up, +X to the right, and -Z forward.
+
+## VIVE Plugin
+
+After adding the "VIVE Focus3 Wrist Tracker" to "Project Settings > XR Plugin-in Management > OpenXR > Android Tab > Interaction Profiles", you can use the following Input Action Pathes.
+
+### Left Hand
+- <ViveWristTracker>{LeftHand}/primaryButton: Left tracker primary button pressed state.
+- <ViveWristTracker>{LeftHand}/menu: Left tracker menu button pressed state.
+- <ViveWristTracker>{LeftHand}/devicePose: Left tracker pose.
+- <ViveWristTracker>{LeftHand}/devicePose/isTracked: Left tracker tracking state.
+
+### Right Hand
+- <ViveWristTracker>{RightHand}/primaryButton: Right tracker primary button pressed state.
+- <ViveWristTracker>{RightHand}/menu: Right tracker menu button pressed state.
+- <ViveWristTracker>{RightHand}/devicePose: Right tracker pose.
+- <ViveWristTracker>{RightHand}/devicePose/isTracked: Right tracker tracking state.
+
+Refer to the <VIVE OpenXR sample path>/Plugin/Input/ActionMap/InputActions.inputActions about the "Input Action Path" usage and the sample <VIVE OpenXR sample path>/Plugin/Input/OpenXRInput.unity.

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2c68233f6b41d7145b07de86f5d16638
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 771c0636a727c9742971602d5da26011
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Scripts/ViveFoveation.cs

@@ -0,0 +1,105 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+using System.Runtime.InteropServices;
+using System;
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR
+{
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Foveation",
+		Desc = "Support the HTC foveation extension.",
+		Company = "HTC",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenxrExtensionString,
+		Version = "1.0.0",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+        FeatureId = featureId
+	)]
+#endif
+    public class ViveFoveation : OpenXRFeature
+    {
+		const string LOG_TAG = "VIVE.OpenXR.ViveFoveation";
+		void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
+		void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
+		void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
+
+		/// <summary>
+		/// Flag bits for XrFoveationDynamicFlagsHTC
+		/// </summary>
+		public const UInt64 XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC = 0x00000001;
+		public const UInt64 XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC = 0x00000002;
+		public const UInt64 XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC = 0x00000004;
+
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.foveation";
+
+		/// <summary>
+		/// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation">12.90. XR_HTC_foveation</see>.
+		/// </summary>
+		public const string kOpenxrExtensionString = "XR_HTC_foveation";
+
+		#region OpenXR Life Cycle
+		/// <summary>
+		/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+		/// </summary>
+		/// <param name="xrInstance">The created instance.</param>
+		/// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+			{
+				WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
+				return false;
+			}
+
+			DEBUG("OnInstanceCreate() " + xrInstance);
+
+			return true;
+		}
+		#endregion
+
+		protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+		{
+			Debug.Log("EXT: registering our own xrGetInstanceProcAddr");
+            if (SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Vulkan)
+            {
+                Debug.Log("Vulkan no hook foveation");
+                return func;
+            }
+            return intercept_xrGetInstanceProcAddr(func);
+		}
+
+		private const string ExtLib = "viveopenxr";
+		[DllImport(ExtLib, EntryPoint = "intercept_xrGetInstanceProcAddr")]
+		private static extern IntPtr intercept_xrGetInstanceProcAddr(IntPtr func);
+
+		[DllImport(ExtLib, EntryPoint = "applyFoveationHTC")]
+		private static extern XrResult applyFoveationHTC(Foveation.XrFoveationModeHTC mode, UInt32 configCount, Foveation.XrFoveationConfigurationHTC[] configs, UInt64 flags);
+
+		/// <summary>
+		/// function to apply HTC Foveation
+		/// </summary>
+		public static XrResult ApplyFoveationHTC(Foveation.XrFoveationModeHTC mode, UInt32 configCount, Foveation.XrFoveationConfigurationHTC[] configs, UInt64 flags = 0)
+		{
+			//Debug.Log("Unity HTCFoveat:configCount " + configCount);
+			//if (configCount >=2) {
+				//Debug.Log("Unity HTCFoveat:configs[0].clearFovDegree " + configs[0].clearFovDegree);
+				//Debug.Log("Unity HTCFoveat:configs[0].level " + configs[0].level);
+				//Debug.Log("Unity HTCFoveat:configs[1].clearFovDegree " + configs[1].clearFovDegree);
+				//Debug.Log("Unity HTCFoveat:configs[1].level " + configs[1].level);
+			//}
+			return applyFoveationHTC(mode, configCount, configs, flags);
+		}
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Scripts/ViveFoveation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 17b6a897c202288439905d3efb0e006f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Scripts/ViveFoveationHelper.cs

@@ -0,0 +1,38 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+namespace VIVE.OpenXR.Foveation
+{
+    #region 12.86. XR_HTC_foveation
+    /// <summary>
+    /// The XrFoveationModeHTC identifies the different foveation modes.
+    /// </summary>
+    public enum XrFoveationModeHTC
+    {
+        XR_FOVEATION_MODE_DISABLE_HTC = 0,
+        XR_FOVEATION_MODE_FIXED_HTC = 1,
+        XR_FOVEATION_MODE_DYNAMIC_HTC = 2,
+        XR_FOVEATION_MODE_CUSTOM_HTC = 3,
+        XR_FOVEATION_MODE_MAX_ENUM_HTC = 0x7FFFFFFF
+    }
+    /// <summary>
+    /// The XrFoveationLevelHTC identifies the pixel density drop level of periphery area.
+    /// </summary>
+    public enum XrFoveationLevelHTC
+    {
+        XR_FOVEATION_LEVEL_NONE_HTC = 0,
+        XR_FOVEATION_LEVEL_LOW_HTC = 1,
+        XR_FOVEATION_LEVEL_MEDIUM_HTC = 2,
+        XR_FOVEATION_LEVEL_HIGH_HTC = 3,
+        XR_FOVEATION_LEVEL_MAX_ENUM_HTC = 0x7FFFFFFF
+    }
+    /// <summary>
+    /// The XrFoveationConfigurationHTC structure contains the custom foveation settings for the corresponding views.
+    /// </summary>
+    public struct XrFoveationConfigurationHTC
+    {
+        public XrFoveationLevelHTC level;
+        public float clearFovDegree;
+        public XrVector2f focalCenterOffset;
+    }
+    #endregion
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/Foveation/Scripts/ViveFoveationHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b3c2ad651da4e5498f49d3a26038620
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 83e064b5ad501784c898651afc560f8e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 73f495f4b0dd14245b3997ffbe23713a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Documentation/OpenXRExtensions.md

@@ -0,0 +1,18 @@
+# 12.1. XR_HTC_frame_synchronization
+## Overview
+The application frame loop relies on xrWaitFrame throttling to synchronize application frame submissions with the display. This extension allows the application to set the frame synchronization mode to adjust the interval between the application frame submission time and the corresponding display time according to the demand of the application. The runtime will return the appropriate XrFrameState::predictedDisplayTime returned by xrWaitFrame to throttle the frame loop approaching to the frame rendering time of the application with the consistent good user experience throughout the session.
+## Name String
+    XR_HTC_frame_synchronization
+## Revision
+    1
+## New Enum Constants
+[XrStructureType](https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XrStructureType) enumeration is extended with:
+- XR_TYPE_FRAME_SYNCHRONIZATION_SESSION_BEGIN_INFO_HTC
+## New Enums
+- XrFrameSynchronizationModeHTC
+## New Structures
+- XrFrameSynchronizationSessionBeginInfoHTC
+
+## VIVE Plugin
+
+Enable "VIVE XR Frame Synchronization" in "Project Settings > XR Plugin-in Management > OpenXR > Android Tab > OpenXR Feature Groups" to use the frame synchronization provided by VIVE OpenXR plugin.

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 190a1897e332b7f45893a24c3f696567
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a8078a459f75c5d419c46950680d6446
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Scripts/ViveFrameSynchronization.cs

@@ -0,0 +1,165 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Text;
+using UnityEngine;
+using UnityEngine.XR.OpenXR;
+using UnityEngine.XR.OpenXR.Features;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.FrameSynchronization
+{
+#if UNITY_EDITOR
+	[OpenXRFeature(UiName = "VIVE XR Frame Synchronization (Beta)",
+		BuildTargetGroups = new[] { BuildTargetGroup.Android },
+		Company = "HTC",
+		Desc = "Support the Frame Synchronization extension.",
+		DocumentationLink = "..\\Documentation",
+		OpenxrExtensionStrings = kOpenxrExtensionString,
+		Version = "1.0.0",
+		FeatureId = featureId)]
+#endif
+	public class ViveFrameSynchronization : OpenXRFeature
+	{
+		#region Log
+		const string LOG_TAG = "VIVE.OpenXR.FrameSynchronization.ViveFrameSynchronization";
+		StringBuilder m_sb = null;
+		StringBuilder sb  {
+			get {
+				if (m_sb == null) { m_sb = new StringBuilder(); }
+				return m_sb;
+			}
+		}
+		void DEBUG(StringBuilder msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
+		void WARNING(StringBuilder msg) { Debug.LogWarningFormat("{0} {1}", LOG_TAG, msg); }
+		void ERROR(StringBuilder msg) { Debug.LogErrorFormat("{0} {1}", LOG_TAG, msg); }
+		#endregion
+
+		/// <summary>
+		/// The extension name of 12.1. XR_HTC_frame_synchronization.
+		/// </summary>
+		public const string kOpenxrExtensionString = "XR_HTC_frame_synchronization";
+		/// <summary>
+		/// The feature id string. This is used to give the feature a well known id for reference.
+		/// </summary>
+		public const string featureId = "vive.openxr.feature.framesynchronization";
+
+		#region OpenXR Life Cycle
+		/// <inheritdoc />
+		protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
+		{
+			sb.Clear().Append("HookGetInstanceProcAddr() xrBeginSession"); DEBUG(sb);
+
+			ViveInterceptors.Instance.AddRequiredFunction("xrBeginSession");
+			return ViveInterceptors.Instance.HookGetInstanceProcAddr(func);
+		}
+
+#pragma warning disable
+		private bool m_XrInstanceCreated = false;
+#pragma warning enable
+		private XrInstance m_XrInstance = 0;
+		/// <summary>
+		/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+		/// </summary>
+		/// <param name="xrInstance">The created instance.</param>
+		/// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+		protected override bool OnInstanceCreate(ulong xrInstance)
+		{
+			if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+			{
+				sb.Clear().Append("OnInstanceCreate() ").Append(kOpenxrExtensionString).Append(" is NOT enabled."); WARNING(sb);
+				return false;
+			}
+
+			m_XrInstance = xrInstance;
+			m_XrInstanceCreated = true;
+			sb.Clear().Append("OnInstanceCreate() ").Append(m_XrInstance); DEBUG(sb);
+
+			ActivateFrameSynchronization(true);
+
+			return true;
+		}
+		/// <summary>
+		/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyInstance">xrDestroyInstance</see> is done.
+		/// </summary>
+		/// <param name="xrInstance">The instance to destroy.</param>
+		protected override void OnInstanceDestroy(ulong xrInstance)
+		{
+			sb.Clear().Append("OnInstanceDestroy() ").Append(xrInstance).Append(", current: ").Append(m_XrInstance); DEBUG(sb);
+			if (m_XrInstance == xrInstance)
+			{
+				m_XrInstanceCreated = false;
+				m_XrInstance = 0;
+			}
+		}
+
+#pragma warning disable
+		private bool m_XrSessionCreated = false;
+#pragma warning enable
+		private XrSession m_XrSession = 0;
+		/// <summary>
+		/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateSession">xrCreateSession</see> is done.
+		/// </summary>
+		/// <param name="xrSession">The created session ID.</param>
+		protected override void OnSessionCreate(ulong xrSession)
+		{
+			m_XrSession = xrSession;
+			m_XrSessionCreated = true;
+			sb.Clear().Append("OnSessionCreate() ").Append(m_XrSession); DEBUG(sb);
+		}
+		protected override void OnSessionEnd(ulong xrSession)
+		{
+			sb.Clear().Append("OnSessionEnd() ").Append(xrSession).Append(", current: ").Append(m_XrSession); DEBUG(sb);
+		}
+		/// <summary>
+		/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroySession">xrDestroySession</see> is done.
+		/// </summary>
+		/// <param name="xrSession">The session ID to destroy.</param>
+		protected override void OnSessionDestroy(ulong xrSession)
+		{
+			sb.Clear().Append("OnSessionDestroy() ").Append(xrSession).Append(", current: ").Append(m_XrSession); DEBUG(sb);
+			if (m_XrSession == xrSession)
+			{
+				m_XrSessionCreated = false;
+				m_XrSession = 0;
+
+				ActivateFrameSynchronization(false);
+			}
+		}
+
+		private XrSystemId m_XrSystemId = 0;
+		/// <summary>
+		/// Called when the <see cref="XrSystemId">XrSystemId</see> retrieved by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystem">xrGetSystem</see> is changed.
+		/// </summary>
+		/// <param name="xrSystem">The system id.</param>
+		protected override void OnSystemChange(ulong xrSystem)
+		{
+			m_XrSystemId = xrSystem;
+			sb.Clear().Append("OnSystemChange() " + m_XrSystemId); DEBUG(sb);
+		}
+		#endregion
+
+		[SerializeField]
+		internal SynchronizationModeHTC m_SynchronizationMode = SynchronizationModeHTC.Stablized;
+		/// <summary>
+		/// Activate or deactivate the Frame Synchronization feature.
+		/// </summary>
+		/// <param name="active">True for activate</param>
+		/// <param name="mode">The <see cref="XrFrameSynchronizationModeHTC"/> used for Frame Synchronization.</param>
+		private void ActivateFrameSynchronization(bool active)
+		{
+			sb.Clear().Append("ActivateFrameSynchronization() ").Append(active ? "enable " : "disable ").Append(m_SynchronizationMode); DEBUG(sb);
+			ViveInterceptors.Instance.ActivateFrameSynchronization(active, (XrFrameSynchronizationModeHTC)m_SynchronizationMode);
+		}
+
+		/// <summary>
+		/// Retrieves current frame synchronization mode.
+		/// </summary>
+		/// <returns>The mode of <see cref="SynchronizationModeHTC"/>.</returns>
+		public SynchronizationModeHTC GetSynchronizationMode() { return m_SynchronizationMode; }
+	}
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Scripts/ViveFrameSynchronization.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cb48e1e4de80ea8498ba4e9ff34adc32
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Scripts/ViveFrameSynchronizationHelper.cs

@@ -0,0 +1,67 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace VIVE.OpenXR.FrameSynchronization
+{
+	/// <summary>
+	/// The enum alias of <see cref="XrFrameSynchronizationModeHTC"/>.
+	/// </summary>
+	public enum SynchronizationModeHTC : UInt32
+	{
+		Stablized = XrFrameSynchronizationModeHTC.XR_FRAME_SYNCHRONIZATION_MODE_STABILIZED_HTC,
+		Prompt = XrFrameSynchronizationModeHTC.XR_FRAME_SYNCHRONIZATION_MODE_PROMPT_HTC,
+		//Adaptive = XrFrameSynchronizationModeHTC.XR_FRAME_SYNCHRONIZATION_MODE_ADAPTIVE_HTC,
+	}
+
+	// -------------------- 12.1. XR_HTC_frame_synchronization --------------------
+	#region New Enums
+	public enum XrFrameSynchronizationModeHTC : UInt32
+	{
+		XR_FRAME_SYNCHRONIZATION_MODE_STABILIZED_HTC = 1,
+		XR_FRAME_SYNCHRONIZATION_MODE_PROMPT_HTC = 2,
+		XR_FRAME_SYNCHRONIZATION_MODE_ADAPTIVE_HTC = 3,
+		XR_FRAME_SYNCHRONIZATION_MODE_MAX_ENUM_HTC = 0x7FFFFFFF
+	}
+	#endregion
+
+	#region New Structures
+	/// <summary>
+	/// Traditional, runtime will use the latest frame which will cost jitter. With Frame Synchronization, the render frame will not be discarded for smooth gameplay experience.
+	/// However, if the GPU cannot consistently finish rendering on time(rendering more than one vsync at a time), jitter will still occur.Therefore, reducing GPU load is key to smooth gameplay.
+	/// The application can use Frame Synchronization by passing XrFrameSynchronizationSessionBeginInfoHTC at next of <see cref="XrSessionBeginInfo"/>.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct XrFrameSynchronizationSessionBeginInfoHTC
+	{
+		/// <summary>
+		/// The XrStructureType of this structure. It must be XR_TYPE_FRAME_SYNCHRONIZATION_SESSION_BEGIN_INFO_HTC.
+		/// </summary>
+		public XrStructureType type;
+		/// <summary>
+		/// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
+		/// </summary>
+		public IntPtr next;
+		/// <summary>
+		/// The frame synchronization mode to be used in this session.
+		/// </summary>
+		public XrFrameSynchronizationModeHTC mode;
+
+		public XrFrameSynchronizationSessionBeginInfoHTC(XrStructureType in_type, IntPtr in_next, XrFrameSynchronizationModeHTC in_mode)
+		{
+			type = in_type;
+			next = in_next;
+			mode = in_mode;
+		}
+		public static XrFrameSynchronizationSessionBeginInfoHTC identity {
+			get {
+				return new XrFrameSynchronizationSessionBeginInfoHTC(
+					XrStructureType.XR_TYPE_FRAME_SYNCHRONIZATION_SESSION_BEGIN_INFO_HTC,
+					IntPtr.Zero,
+					XrFrameSynchronizationModeHTC.XR_FRAME_SYNCHRONIZATION_MODE_STABILIZED_HTC);
+			}
+		}
+	}
+	#endregion
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/FrameSynchronization/Scripts/ViveFrameSynchronizationHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a2877a2048174774b8e8698f159199e9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1d77b72e71f09834b8a271fafab43127
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e96f290ae08cd3642932e5fd10d142e8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 771c4b3ec0a607546b6188ee58213b92
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Documentation/OpenXRExtensions.md

@@ -0,0 +1,97 @@
+# 12.67 XR_HTC_hand_interaction
+## Name String
+    XR_HTC_hand_interaction
+## Revision
+    1
+## Hand Interaction Profile
+### Interaction profile path:
+- /interaction_profiles/htc/hand_interaction
+
+### Valid for user paths:
+- /user/hand_htc/left
+- /user/hand_htc/right
+
+### Supported input source
+- <20>K/input/select/value
+- <20>K/input/aim/pose
+
+The application should use <20>K/input/aim/pose path to aim at objects in the world and use <20>K/input/select/value path to decide user selection from pinch shape strength which the range of value is 0.0f to 1.0f, with 1.0f meaning pinch fingers touched.
+
+## VIVE Plugin
+
+After adding the "VIVE XR Hand Interaction" to "Project Settings > XR Plugin-in Management > OpenXR > Android Tab > Interaction Profiles", you can use the following Input Action Pathes.
+
+### Left Hand
+- <ViveHandInteraction>{LeftHand}/selectValue: Presents the left hand pinch strength.
+- <ViveHandInteraction>{LeftHand}/pointerPose: Presents the left hand pinch pose.
+
+### Right Hand
+- <ViveHandInteraction>{RightHand}/selectValue: Presents the right hand pinch strength.
+- <ViveHandInteraction>{RightHand}/pointerPose: Presents the right hand pinch pose.
+
+Refer to the <VIVE OpenXR sample path>/Samples/Commons/ActionMap/InputActions.inputActions about the "Input Action Path" usage in the sample <VIVE OpenXR sample path>/Samples/Input/OpenXRInput.unity.
+
+--------------------
+
+# 12.31. XR_EXT_hand_interaction
+## Name String
+    XR_EXT_hand_interaction
+## Revision
+    1
+## Hand Interaction Profile
+### Interaction profile path:
+- /interaction_profiles/ext/hand_interaction_ext
+
+### Valid for user paths:
+- /user/hand/left
+- /user/hand/right
+
+### Supported input source
+- <20>K/input/aim/pose
+- <20>K/input/aim_activate_ext/value: a 1D analog input component indicating that the user activated the action on the target that the user is pointing at with the aim pose.
+- <20>K/input/aim_activate_ext/ready_ext: a boolean input, where the value XR_TRUE indicates that the fingers to perform the "aim_activate" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing an "aim_activate" gesture.
+- <20>K/input/grip/pose
+- <20>K/input/grasp_ext/value: a 1D analog input component indicating that the user is making a fist.
+- <20>K/input/grasp_ext/ready_ext: a boolean input, where the value XR_TRUE indicates that the hand performing the grasp action is properly tracked by the hand tracking device and it is observed to be ready to perform or is performing the grasp action.
+- <20>K/input/pinch_ext/pose
+- <20>K/input/pinch_ext/value: a 1D analog input component indicating the extent which the user is bringing their finger and thumb together to perform a "pinch" gesture.
+- <20>K/input/pinch_ext/ready_ext: a boolean input, where the value XR_TRUE indicates that the fingers used to perform the "pinch" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing a "pinch" gesture.
+- <20>K/input/poke_ext/pose
+
+The <20>K/input/aim/pose is typically used for aiming at objects out of arm<72><6D>s reach. When using a hand interaction profile, it is typically paired with <20>K/input/aim_activate_ext/value to optimize aiming ray stability while performing the gesture. When using a controller interaction profile, the "aim" pose is typically paired with a trigger or a button for aim and fire operations.
+
+The <20>K/input/grip/pose is typically used for holding a large object in the user<65><72>s hand. When using a hand interaction profile, it is typically paired with <20>K/input/grasp_ext/value for the user to directly manipulate an object held in a hand. When using a controller interaction profile, the "grip" pose is typically paired with a "squeeze" button or trigger that gives the user the sense of tightly holding an object.
+
+The <20>K/input/pinch_ext/pose is typically used for directly manipulating a small object using the pinch gesture. When using a hand interaction profile, it is typically paired with the <20>K/input/pinch_ext/value gesture. When using a controller interaction profile, it is typically paired with a trigger manipulated with the index finger, which typically requires curling the index finger and applying pressure with the fingertip.
+
+The <20>K/input/poke_ext/pose is typically used for contact-based interactions using the motion of the hand or fingertip. It typically does not pair with other hand gestures or buttons on the controller. The application typically uses a sphere collider with the "poke" pose to visualize the pose and detect touch with a virtual object.
+
+## VIVE Plugin
+
+After adding the "VIVE XR Hand Interaction Ext" to "Project Settings > XR Plugin-in Management > OpenXR > Android Tab > Interaction Profiles", you can use the following Input Action Pathes.
+
+### Left Hand
+- <ViveHandInteraction>{LeftHand}/pointerPose: Presents the left hand aim pose used for aiming at objects out of arm<72><6D>s reach.
+- <ViveHandInteraction>{LeftHand}/pointerValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the aimed-at target is being fully interacted with left hand.
+- <ViveHandInteraction>{LeftHand}/pointerReady: XR_TRUE indicates that the left fingers to perform the "aim_activate" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing an "aim_activate" gesture.
+- <ViveHandInteraction>{LeftHand}/gripPose: Presents the left hand grip pose used for holding a large object in the user<65><72>s hand.
+- <ViveHandInteraction>{LeftHand}/gripValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the left fist is tightly closed.
+- <ViveHandInteraction>{LeftHand}/gripReady: XR_TRUE indicates that the left hand performing the grasp action is properly tracked by the hand tracking device and it is observed to be ready to perform or is performing the grasp action.
+- <ViveHandInteraction>{LeftHand}/pinchPose: Presents the left hand pinch pose used for directly manipulating a small object using the pinch gesture.
+- <ViveHandInteraction>{LeftHand}/pinchValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the left finger and thumb are touching each other.
+- <ViveHandInteraction>{LeftHand}/pinchReady: XR_TRUE indicates that the left fingers used to perform the "pinch" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing a "pinch" gesture.
+- <ViveHandInteraction>{LeftHand}/pokePose: Presents the left hand poke pose used for contact-based interactions using the motion of the hand or fingertip.
+
+### Right Hand
+- <ViveHandInteraction>{RightHand}/pointerPose: Presents the right hand aim pose used for aiming at objects out of arm<72><6D>s reach.
+- <ViveHandInteraction>{RightHand}/pointerValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the aimed-at target is being fully interacted with right hand.
+- <ViveHandInteraction>{RightHand}/pointerReady: XR_TRUE indicates that the right fingers to perform the "aim_activate" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing an "aim_activate" gesture.
+- <ViveHandInteraction>{RightHand}/gripPose: Presents the right hand grip pose used for holding a large object in the user<65><72>s hand.
+- <ViveHandInteraction>{RightHand}/gripValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the right fist is tightly closed.
+- <ViveHandInteraction>{RightHand}/gripReady: XR_TRUE indicates that the right hand performing the grasp action is properly tracked by the hand tracking device and it is observed to be ready to perform or is performing the grasp action.
+- <ViveHandInteraction>{RightHand}/pinchPose: Presents the right hand pinch pose used for directly manipulating a small object using the pinch gesture.
+- <ViveHandInteraction>{RightHand}/pinchValue: Can be used as either a boolean or float action type, where the value XR_TRUE or 1.0f represents that the right finger and thumb are touching each other.
+- <ViveHandInteraction>{RightHand}/pinchReady: XR_TRUE indicates that the right fingers used to perform the "pinch" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing a "pinch" gesture.
+- <ViveHandInteraction>{RightHand}/pokePose: Presents the right hand poke pose used for contact-based interactions using the motion of the hand or fingertip.
+
+Refer to the <VIVE OpenXR sample path>/Samples/HandInteractionExt/HandInteractionExt.inputActions about the "Input Action Path" usage in the sample <VIVE OpenXR sample path>/Samples/HandInteractionExt/HandInteractionExt.unity.

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f1983ec0f3f6f1841b9824ef68235039
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8626a4ae9aacf7d41b32411a6e5a04f9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Scripts/ViveHandInteraction.cs

@@ -0,0 +1,363 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using UnityEngine.Scripting;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine.InputSystem.Layouts;
+using UnityEngine.InputSystem.XR;
+using UnityEngine.InputSystem.Controls;
+using UnityEngine.XR.OpenXR;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using System.Collections.Generic;
+using UnityEngine.XR;
+using UnityEngine.XR.OpenXR.Input;
+using System.Text;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+#if USE_INPUT_SYSTEM_POSE_CONTROL // Scripting Define Symbol added by using OpenXR Plugin 1.6.0.
+using PoseControl = UnityEngine.InputSystem.XR.PoseControl;
+#else
+using PoseControl = UnityEngine.XR.OpenXR.Input.PoseControl;
+#endif
+
+namespace VIVE.OpenXR.Hand
+{
+    /// <summary>
+    /// This <see cref="OpenXRInteractionFeature"/> enables the use of hand interaction profiles in OpenXR. It enables <see cref="ViveHandInteraction.kOpenxrExtensionString">XR_HTC_hand_interaction</see> in the underyling runtime.
+    /// </summary>
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Hand Interaction",
+        Hidden = true,
+        BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
+        Company = "HTC",
+        Desc = "Support for enabling the VIVE hand interaction profile. Will register the controller map for hand interaction if enabled.",
+        DocumentationLink = "https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_HTC_hand_interaction",
+        Version = "1.0.0",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Category = FeatureCategory.Interaction,
+        FeatureId = featureId)]
+#endif
+    public class ViveHandInteraction : OpenXRInteractionFeature
+    {
+        #region Log
+        const string LOG_TAG = "VIVE.OpenXR.Hand.ViveHandInteraction ";
+        StringBuilder m_sb = null;
+        StringBuilder sb {
+            get {
+                if (m_sb == null) { m_sb = new StringBuilder(); }
+                return m_sb;
+            }
+        }
+        void DEBUG(StringBuilder msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
+        void WARNING(StringBuilder msg) { Debug.LogWarningFormat("{0} {1}", LOG_TAG, msg); }
+        #endregion
+
+        /// <summary>
+        /// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_hand_interaction">12.69. XR_HTC_hand_interaction</see>.
+        /// </summary>
+        public const string kOpenxrExtensionString = "XR_HTC_hand_interaction";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.hand.interaction";
+
+        /// <summary>
+        /// The interaction profile string used to reference the hand interaction input device.
+        /// </summary>
+        private const string profile = "/interaction_profiles/htc/hand_interaction";
+
+        #region Supported component paths
+        private const string leftHand = "/user/hand_htc/left";
+        private const string rightHand = "/user/hand_htc/right";
+
+        /// <summary>
+        /// Constant for a float interaction binding '.../input/select/value' OpenXR Input Binding. Used by input subsystem to bind actions to physical inputs.
+        /// </summary>
+        public const string selectValue = "/input/select/value";
+
+        /// <summary>
+        /// Constant for a float interaction binding '.../input/squeeze/value' OpenXR Input Binding. Used by input subsystem to bind actions to physical inputs.
+        /// </summary>
+        public const string gripValue = "/input/squeeze/value";
+
+
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/aim/pose' OpenXR Input Binding. Used by input subsystem to bind actions to physical inputs.
+        /// </summary>
+        public const string pointerPose = "/input/aim/pose";
+
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/grip/pose' OpenXR Input Binding. Used by input subsystem to bind actions to physical inputs.
+        /// </summary>
+        public const string devicePose = "/input/grip/pose";
+        #endregion
+
+        [Preserve, InputControlLayout(displayName = "VIVE Hand Interaction (OpenXR)", commonUsages = new[] { "LeftHand", "RightHand" }, isGenericTypeOfDevice = true)]
+        public class HandInteractionDevice : OpenXRDevice
+        {
+            const string LOG_TAG = "VIVE.OpenXR.Hand.ViveHandInteraction.HandInteractionDevice";
+            void DEBUG(string msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
+
+            /// <summary>
+            /// A <see cref="AxisControl"/> representing the <see cref="ViveHandInteraction.selectValue"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "selectAxis, pinchStrength" }, usage = "Select")]
+            public AxisControl selectValue { get; private set; }
+
+            /// <summary>
+            /// A <see cref="AxisControl"/> representing information from the <see cref="ViveHandInteraction.squeeze"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "GripAxis" }, usage = "Grip")]
+            public AxisControl gripValue { get; private set; }
+
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing information from the <see cref="ViveHandInteraction.devicePose"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(offset = 0, aliases = new[] { "device", "gripPose" }, usage = "Device")]
+            public PoseControl devicePose { get; private set; }
+
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing the <see cref="ViveHandInteraction.pointerPose"/> OpenXR binding.
+            /// </summary>
+			[Preserve, InputControl(offset = 0, alias = "aimPose", usage = "Pointer")]
+            public PoseControl pointerPose { get; private set; }
+
+            /// <summary>
+            /// A [ButtonControl](xref:UnityEngine.InputSystem.Controls.ButtonControl) required for backwards compatibility with the XRSDK layouts. This represents the overall tracking state of the device. This value is equivalent to mapping devicePose/isTracked.
+            /// </summary>
+            [Preserve, InputControl(offset = 8)]
+            public ButtonControl isTracked { get; private set; }
+
+            /// <summary>
+            /// A [IntegerControl](xref:UnityEngine.InputSystem.Controls.IntegerControl) required for backwards compatibility with the XRSDK layouts. This represents the bit flag set to indicate what data is valid. This value is equivalent to mapping devicePose/trackingState.
+            /// </summary>
+            [Preserve, InputControl(offset = 12)]
+            public IntegerControl trackingState { get; private set; }
+
+            /// <summary>
+            /// A [Vector3Control](xref:UnityEngine.InputSystem.Controls.Vector3Control) required for backwards compatibility with the XRSDK layouts. This is the device position. This value is equivalent to mapping devicePose/position.
+            /// </summary>
+            [Preserve, InputControl(offset = 16, alias = "gripPosition")]
+            public Vector3Control devicePosition { get; private set; }
+
+            /// <summary>
+            /// A [QuaternionControl](xref:UnityEngine.InputSystem.Controls.QuaternionControl) required for backwards compatibility with the XRSDK layouts. This is the device orientation. This value is equivalent to mapping devicePose/rotation.
+            /// </summary>
+            [Preserve, InputControl(offset = 28, alias = "gripOrientation")]
+            public QuaternionControl deviceRotation { get; private set; }
+
+
+            /// <summary>
+            /// Internal call used to assign controls to the the correct element.
+            /// </summary>
+            protected override void FinishSetup()
+            {
+                DEBUG("FinishSetup() interfaceName: " + description.interfaceName
+                    + ", deviceClass: " + description.deviceClass
+                    + ", product: " + description.product
+                    + ", serial: " + description.serial
+                    + ", version: " + description.version);
+
+                base.FinishSetup();
+
+                selectValue = GetChildControl<AxisControl>("selectValue");
+                gripValue = GetChildControl<AxisControl>("gripValue");
+
+                devicePose = GetChildControl<PoseControl>("devicePose");
+                pointerPose = GetChildControl<PoseControl>("pointerPose");
+
+                isTracked = GetChildControl<ButtonControl>("isTracked");
+                trackingState = GetChildControl<IntegerControl>("trackingState");
+                devicePosition = GetChildControl<Vector3Control>("devicePosition");
+                deviceRotation = GetChildControl<QuaternionControl>("deviceRotation");
+            }
+        }
+
+#pragma warning disable
+        private bool m_XrInstanceCreated = false;
+#pragma warning restore
+        private XrInstance m_XrInstance = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The created instance.</param>
+        /// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+            {
+                sb.Clear().Append("OnInstanceCreate() ").Append(kOpenxrExtensionString).Append(" is NOT enabled."); WARNING(sb);
+                return false;
+            }
+
+            m_XrInstanceCreated = true;
+            m_XrInstance = xrInstance;
+            sb.Clear().Append("OnInstanceCreate() " + m_XrInstance); DEBUG(sb);
+
+            return base.OnInstanceCreate(xrInstance);
+        }
+
+        private const string kLayoutName = "ViveHandInteraction";
+        private const string kDeviceLocalizedName = "Vive Hand Interaction OpenXR";
+        /// <summary>
+        /// Registers the <see cref="HandInteractionDevice"/> layout with the Input System.
+        /// </summary>
+        protected override void RegisterDeviceLayout()
+        {
+            sb.Clear().Append("RegisterDeviceLayout() ").Append(kLayoutName).Append(", product: ").Append(kDeviceLocalizedName); DEBUG(sb);
+            InputSystem.RegisterLayout(typeof(HandInteractionDevice),
+                kLayoutName,
+                matches: new InputDeviceMatcher()
+                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
+                    .WithProduct(kDeviceLocalizedName));
+        }
+
+        /// <summary>
+        /// Removes the <see cref="HandInteractionDevice"/> layout from the Input System.
+        /// </summary>
+        protected override void UnregisterDeviceLayout()
+        {
+            sb.Clear().Append("UnregisterDeviceLayout() ").Append(kLayoutName); DEBUG(sb);
+            InputSystem.RemoveLayout(kLayoutName);
+        }
+
+#if UNITY_XR_OPENXR_1_9_1
+        /// <summary>
+        /// Return interaction profile type. HandInteractionDevice profile is Device type.
+        /// </summary>
+        /// <returns>Interaction profile type.</returns>
+        protected override InteractionProfileType GetInteractionProfileType()
+        {
+            return typeof(HandInteractionDevice).IsSubclassOf(typeof(XRController)) ? InteractionProfileType.XRController : InteractionProfileType.Device;
+        }
+
+        /// <summary>
+        /// Return device layer out string used for registering device HandInteractionDevice in InputSystem.
+        /// </summary>
+        /// <returns>Device layout string.</returns>
+        protected override string GetDeviceLayoutName()
+        {
+            return kLayoutName;
+        }
+#endif
+
+        /// <summary>
+        /// Registers action maps to Unity XR.
+        /// </summary>
+        protected override void RegisterActionMapsWithRuntime()
+        {
+            sb.Clear().Append("RegisterActionMapsWithRuntime() Action map vivehandinteraction")
+                .Append(", localizedName: ").Append(kDeviceLocalizedName)
+                .Append(", desiredInteractionProfile").Append(profile);
+            DEBUG(sb);
+
+            ActionMapConfig actionMap = new ActionMapConfig()
+            {
+                name = "vivehandinteraction",
+                localizedName = kDeviceLocalizedName,
+                desiredInteractionProfile = profile,
+                manufacturer = "HTC",
+                serialNumber = "",
+                deviceInfos = new List<DeviceConfig>()
+                {
+                    new DeviceConfig()
+                    {
+                        characteristics = InputDeviceCharacteristics.TrackedDevice | InputDeviceCharacteristics.HandTracking | InputDeviceCharacteristics.Left,
+                        userPath = leftHand // "/user/hand_htc/left"
+                    },
+                    new DeviceConfig()
+                    {
+                        characteristics = InputDeviceCharacteristics.TrackedDevice | InputDeviceCharacteristics.HandTracking | InputDeviceCharacteristics.Right,
+                        userPath = rightHand // "/user/hand_htc/right"
+                    }
+                },
+                actions = new List<ActionConfig>()
+                {
+                    // Grip Axis
+                    new ActionConfig()
+                    {
+                        name = "gripValue",
+                        localizedName = "Grip Axis",
+                        type = ActionType.Axis1D,
+                        usages = new List<string>()
+                        {
+                            "Grip"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = gripValue,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+					// Select Axis
+					new ActionConfig()
+                    {
+                        name = "selectValue",
+                        localizedName = "Select Axis",
+                        type = ActionType.Axis1D,
+                        usages = new List<string>()
+                        {
+                            "Select"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = selectValue,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Grip pose
+                    new ActionConfig()
+                    {
+                        name = "devicePose",
+                        localizedName = "Device Pose",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Device"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = devicePose,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+					// Pointer Pose
+					new ActionConfig()
+                    {
+                        name = "pointerPose",
+                        localizedName = "Pointer Pose",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Pointer"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pointerPose,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    }
+                }
+            };
+
+            AddActionMap(actionMap);
+        }
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Scripts/ViveHandInteraction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec058e82c4fd831488e0fe81bb41d440
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Scripts/ViveHandInteractionExt.cs

@@ -0,0 +1,587 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using UnityEngine.Scripting;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine.InputSystem.Layouts;
+using UnityEngine.InputSystem.XR;
+using UnityEngine.InputSystem.Controls;
+using UnityEngine.XR.OpenXR;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using System.Collections.Generic;
+using UnityEngine.XR;
+using UnityEngine.XR.OpenXR.Input;
+using System;
+using System.Text;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+#if USE_INPUT_SYSTEM_POSE_CONTROL // Scripting Define Symbol added by using OpenXR Plugin 1.6.0.
+using PoseControl = UnityEngine.InputSystem.XR.PoseControl;
+#else
+using PoseControl = UnityEngine.XR.OpenXR.Input.PoseControl;
+#endif
+
+namespace VIVE.OpenXR.Hand
+{
+    /// <summary>
+    /// This <see cref="OpenXRInteractionFeature"/> enables the use of hand interaction profiles in OpenXR. It enables <see cref="ViveHandInteractionExt.kOpenxrExtensionString">XR_EXT_hand_interaction</see> in the underyling runtime.
+    /// </summary>
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Hand Interaction Ext (Deprecated)",
+        Hidden = true,
+        BuildTargetGroups = new[] { BuildTargetGroup.Android },
+        Company = "HTC",
+        Desc = "Support for enabling the KHR hand interaction profile. Will register the controller map for hand interaction if enabled.",
+        DocumentationLink = "https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_EXT_hand_interaction",
+        Version = "1.0.0",
+        OpenxrExtensionStrings = kOpenxrExtensionString,
+        Category = FeatureCategory.Interaction,
+        FeatureId = featureId)]
+#endif
+    [Obsolete("This class is deprecated. Please use Unity Hand Interaction Profile instead.")]
+    public class ViveHandInteractionExt : OpenXRInteractionFeature
+    {
+        #region Log
+        const string LOG_TAG = "VIVE.OpenXR.Hand.ViveHandInteractionExt";
+        StringBuilder m_sb = null;
+        StringBuilder sb {
+            get {
+                if (m_sb == null) { m_sb = new StringBuilder(); }
+                return m_sb;
+            }
+        }
+        void DEBUG(StringBuilder msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
+        void WARNING(StringBuilder msg) { Debug.LogWarningFormat("{0} {1}", LOG_TAG, msg); }
+        #endregion
+
+		/// <summary>
+		/// OpenXR specification <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_hand_interaction">12.69. XR_HTC_hand_interaction</see>.
+		/// </summary>
+		public const string kOpenxrExtensionString = "XR_EXT_hand_interaction";
+
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "vive.openxr.feature.hand.interaction.ext";
+
+        [Preserve, InputControlLayout(displayName = "VIVE Hand Interaction Ext (OpenXR)", commonUsages = new[] { "LeftHand", "RightHand" })]
+        public class HandInteractionExtDevice : XRController
+        {
+            #region Log
+            const string LOG_TAG = "VIVE.OpenXR.Hand.ViveHandInteractionExt.HandInteractionExtDevice";
+            void DEBUG(string msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
+            #endregion
+
+            #region Action Path
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing the <see cref="ViveHandInteractionExt.grip"/> OpenXR binding.
+            /// </summary>
+			[Preserve, InputControl(offset = 0, aliases = new[] { "device", "gripPose" }, usage = "Device")]
+            public PoseControl devicePose { get; private set; }
+
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing the <see cref="ViveHandInteractionExt.aim"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(offset = 0, alias = "aimPose", usage = "Pointer")]
+            public PoseControl pointer { get; private set; }
+
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing the <see cref="ViveHandInteractionExt.pinchPose"/> OpenXR binding.
+            /// </summary>
+			[Preserve, InputControl(offset = 0, usage = "Pinch")]
+            public PoseControl pinchPose { get; private set; }
+
+            /// <summary>
+            /// A <see cref="PoseControl"/> representing the <see cref="ViveHandInteractionExt.poke"/> OpenXR binding.
+            /// </summary>
+			[Preserve, InputControl(offset = 0, alias = "indexTip", usage = "Poke")]
+            public PoseControl pokePose { get; private set; }
+
+            /// <summary>
+            /// A <see cref="AxisControl"/> representing information from the <see cref="ViveHandInteractionExt.graspValue"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "gripValue" }, usage = "GraspValue")]
+            public AxisControl graspValue { get; private set; }
+            /// <summary>
+            /// A <see cref="ButtonControl"/> representing the <see cref="ViveHandInteractionExt.graspReady"/> OpenXR bindings, depending on handedness.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "isGrasped", "isGripped" }, usage = "GraspReady")]
+            public ButtonControl graspReady { get; private set; }
+
+            /// <summary>
+            /// A <see cref="AxisControl"/> representing information from the <see cref="ViveHandInteractionExt.pointerActivateValue"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "pointerValue" }, usage = "PointerActivateValue")]
+            public AxisControl pointerActivateValue { get; private set; }
+            /// <summary>
+            /// A <see cref="ButtonControl"/> representing the <see cref="ViveHandInteractionExt.pointerActivateReady"/> OpenXR bindings, depending on handedness.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "isPointed", "pointerReady" }, usage = "PointerActivateReady")]
+            public ButtonControl pointerActivateReady { get; private set; }
+
+            /// <summary>
+            /// A <see cref="AxisControl"/> representing information from the <see cref="ViveHandInteractionExt.pinchValue"/> OpenXR binding.
+            /// </summary>
+            [Preserve, InputControl(usage = "PinchValue")]
+            public AxisControl pinchValue { get; private set; }
+            /// <summary>
+            /// A <see cref="ButtonControl"/> representing the <see cref="ViveHandInteractionExt.pinchReady"/> OpenXR bindings, depending on handedness.
+            /// </summary>
+            [Preserve, InputControl(aliases = new[] { "isPinched" }, usage = "PinchReady")]
+            public ButtonControl pinchReady { get; private set; }
+
+            /// <summary>
+            /// A [ButtonControl](xref:UnityEngine.InputSystem.Controls.ButtonControl) required for backwards compatibility with the XRSDK layouts. This represents the overall tracking state of the device. This value is equivalent to mapping devicePose/isTracked.
+            /// </summary>
+            [Preserve, InputControl(offset = 2)]
+            new public ButtonControl isTracked { get; private set; }
+            /// <summary>
+            /// A [IntegerControl](xref:UnityEngine.InputSystem.Controls.IntegerControl) required for backwards compatibility with the XRSDK layouts. This represents the bit flag set to indicate what data is valid. This value is equivalent to mapping devicePose/trackingState.
+            /// </summary>
+            [Preserve, InputControl(offset = 4)]
+            new public IntegerControl trackingState { get; private set; }
+            /// <summary>
+            /// A [Vector3Control](xref:UnityEngine.InputSystem.Controls.Vector3Control) required for backwards compatibility with the XRSDK layouts. This is the device position. This value is equivalent to mapping devicePose/position.
+            /// </summary>
+            [Preserve, InputControl(offset = 8, noisy = true, alias = "gripPosition")]
+            new public Vector3Control devicePosition { get; private set; }
+            /// <summary>
+            /// A [QuaternionControl](xref:UnityEngine.InputSystem.Controls.QuaternionControl) required for backwards compatibility with the XRSDK layouts. This is the device orientation. This value is equivalent to mapping devicePose/rotation.
+            /// </summary>
+            [Preserve, InputControl(offset = 20, noisy = true, alias = "gripRotation")]
+            new public QuaternionControl deviceRotation { get; private set; }
+
+            /// <summary>
+            /// A [Vector3Control](xref:UnityEngine.InputSystem.Controls.Vector3Control) required for backwards compatibility with the XRSDK layouts. This is the aim position. This value is equivalent to mapping pointer/position.
+            /// </summary>
+            [Preserve, InputControl(offset = 72, noisy = true)]
+            public Vector3Control pointerPosition { get; private set; }
+            /// <summary>
+            /// A [QuaternionControl](xref:UnityEngine.InputSystem.Controls.QuaternionControl) required for backwards compatibility with the XRSDK layouts. This is the aim orientation. This value is equivalent to mapping pointer/rotation.
+            /// </summary>
+            [Preserve, InputControl(offset = 84, noisy = true)]
+            public QuaternionControl pointerRotation { get; private set; }
+
+            /// <summary>
+            /// A [Vector3Control](xref:UnityEngine.InputSystem.Controls.Vector3Control) required for backwards compatibility with the XRSDK layouts. This is the pinch position. This value is equivalent to mapping pinchPose/position.
+            /// </summary>
+            [Preserve, InputControl(offset = 136, noisy = true)]
+            public Vector3Control pinchPosition { get; private set; }
+            /// <summary>
+            /// A [QuaternionControl](xref:UnityEngine.InputSystem.Controls.QuaternionControl) required for backwards compatibility with the XRSDK layouts. This is the pinch orientation. This value is equivalent to mapping pinchPose/rotation.
+            /// </summary>
+            [Preserve, InputControl(offset = 148, noisy = true)]
+            public QuaternionControl pinchRotation { get; private set; }
+
+            /// <summary>
+            /// A [Vector3Control](xref:UnityEngine.InputSystem.Controls.Vector3Control) required for backwards compatibility with the XRSDK layouts. This is the poke position. This value is equivalent to mapping pokePose/position.
+            /// </summary>
+            [Preserve, InputControl(offset = 200, noisy = true)]
+            public Vector3Control pokePosition { get; private set; }
+            /// <summary>
+            /// A [QuaternionControl](xref:UnityEngine.InputSystem.Controls.QuaternionControl) required for backwards compatibility with the XRSDK layouts. This is the poke orientation. This value is equivalent to mapping pokePose/rotation.
+            /// </summary>
+            [Preserve, InputControl(offset = 212, noisy = true)]
+            public QuaternionControl pokeRotation { get; private set; }
+            #endregion
+
+            /// <summary>
+            /// Internal call used to assign controls to the the correct element.
+            /// </summary>
+            protected override void FinishSetup()
+            {
+                DEBUG("FinishSetup() interfaceName: " + description.interfaceName
+                    + ", deviceClass: " + description.deviceClass
+                    + ", product: " + description.product
+                    + ", serial: " + description.serial
+                    + ", version: " + description.version);
+
+                base.FinishSetup();
+
+                pointer = GetChildControl<PoseControl>("pointer");
+                pointerActivateValue = GetChildControl<AxisControl>("pointerActivateValue");
+                pointerActivateReady = GetChildControl<ButtonControl>("pointerActivateReady");
+
+                devicePose = GetChildControl<PoseControl>("devicePose");
+                graspValue = GetChildControl<AxisControl>("graspValue");
+                graspReady = GetChildControl<ButtonControl>("graspReady");
+
+                pinchPose = GetChildControl<PoseControl>("pinchPose");
+                pinchValue = GetChildControl<AxisControl>("pinchValue");
+                pinchReady = GetChildControl<ButtonControl>("pinchReady");
+
+                pokePose = GetChildControl<PoseControl>("pokePose");
+            }
+        }
+
+        /// <summary>
+        /// The interaction profile string used to reference the hand interaction input device.
+        /// </summary>
+        public const string profile = "/interaction_profiles/ext/hand_interaction_ext";
+
+        #region Supported component paths
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/aim/pose' OpenXR Input Binding.<br></br>
+        /// Typically used for aiming at objects out of arm¡¦s reach. When using a hand interaction profile, it is typically paired with <see cref="pointerActivateValue"/> to optimize aiming ray stability while performing the gesture.<br></br>
+        /// When using a controller interaction profile, the "aim" pose is typically paired with a trigger or a button for aim and fire operations.
+        /// </summary>
+        public const string aim = "/input/aim/pose";
+
+        /// <summary>
+        /// Constant for a float interaction binding '.../input/aim_activate_ext/value' OpenXR Input Binding.<br></br>
+        /// A 1D analog input component indicating that the user activated the action on the target that the user is pointing at with the aim pose.
+        /// </summary>
+        public const string pointerActivateValue = "/input/aim_activate_ext/value";
+
+        /// <summary>
+        /// Constant for a boolean interaction binding '.../input/aim_activate_ext/ready_ext' OpenXR Input Binding.<br></br>
+        /// A boolean input, where the value XR_TRUE indicates that the fingers to perform the "aim_activate" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing an "aim_activate" gesture.
+        /// </summary>
+        public const string pointerActivateReady = "/input/aim_activate_ext/ready_ext";
+
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/grip/pose' OpenXR Input Binding.<br></br>
+        /// Typically used for holding a large object in the user¡¦s hand. When using a hand interaction profile, it is typically paired with <see cref="graspValue"/> for the user to directly manipulate an object held in a hand.<br></br>
+        /// When using a controller interaction profile, the "grip" pose is typically paired with a "squeeze" button or trigger that gives the user the sense of tightly holding an object.
+        /// </summary>
+        public const string grip = "/input/grip/pose";
+
+        /// <summary>
+        /// Constant for a float interaction binding '.../input/grasp_ext/value' OpenXR Input Binding.<br></br>
+        /// A 1D analog input component indicating that the user is making a fist.
+        /// </summary>
+        public const string graspValue = "/input/grasp_ext/value";
+
+        /// <summary>
+        /// Constant for a boolean interaction binding '.../input/grasp_ext/ready_ext' OpenXR Input Binding.<br></br>
+        /// A boolean input, where the value XR_TRUE indicates that the hand performing the grasp action is properly tracked by the hand tracking device and it is observed to be ready to perform or is performing the grasp action.
+        /// </summary>
+        public const string graspReady = "/input/grasp_ext/ready_ext";
+
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/pinch_ext/pose' OpenXR Input Binding.<br></br>
+        /// Typically used for directly manipulating a small object using the pinch gesture. When using a hand interaction profile, it is typically paired with the <see cref="pinchValue"/>.<br></br>
+        /// When using a controller interaction profile, it is typically paired with a trigger manipulated with the index finger, which typically requires curling the index finger and applying pressure with the fingertip.
+        /// </summary>
+        public const string pinchPose = "/input/pinch_ext/pose";
+
+        /// <summary>
+        /// Constant for a float interaction binding '.../input/pinch_ext/value' OpenXR Input Binding.<br></br>
+        /// A 1D analog input component indicating the extent which the user is bringing their finger and thumb together to perform a "pinch" gesture.
+        /// </summary>
+        public const string pinchValue = "/input/pinch_ext/value";
+
+        /// <summary>
+        /// Constant for a boolean interaction binding '.../input/pinch_ext/ready_ext' OpenXR Input Binding.<br></br>
+        /// A boolean input, where the value XR_TRUE indicates that the fingers used to perform the "pinch" gesture are properly tracked by the hand tracking device and the hand shape is observed to be ready to perform or is performing a "pinch" gesture.
+        /// </summary>
+        public const string pinchReady = "/input/pinch_ext/ready_ext";
+
+        /// <summary>
+        /// Constant for a pose interaction binding '.../input/poke_ext/pose' OpenXR Input Binding.<br></br>
+        /// Typically used for contact-based interactions using the motion of the hand or fingertip. It typically does not pair with other hand gestures or buttons on the controller. The application typically uses a sphere collider with the "poke" pose to visualize the pose and detect touch with a virtual object.
+        /// </summary>
+        public const string poke = "/input/poke_ext/pose";
+        #endregion
+
+#pragma warning disable
+        private bool m_XrInstanceCreated = false;
+#pragma warning restore
+        private XrInstance m_XrInstance = 0;
+        /// <summary>
+        /// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
+        /// </summary>
+        /// <param name="xrInstance">The created instance.</param>
+        /// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
+            {
+                sb.Clear().Append("OnInstanceCreate() ").Append(kOpenxrExtensionString).Append(" is NOT enabled."); WARNING(sb);
+                return false;
+            }
+
+            m_XrInstanceCreated = true;
+            m_XrInstance = xrInstance;
+            sb.Clear().Append("OnInstanceCreate() " + m_XrInstance); DEBUG(sb);
+
+            return base.OnInstanceCreate(xrInstance);
+        }
+
+        private const string kLayoutName = "ViveHandInteractionExt";
+        private const string kDeviceLocalizedName = "Vive Hand Interaction Ext OpenXR";
+        /// <summary>
+        /// Registers the <see cref="HandInteractionExtDevice"/> layout with the Input System.
+        /// </summary>
+        protected override void RegisterDeviceLayout()
+        {
+            sb.Clear().Append("RegisterDeviceLayout() ").Append(kLayoutName).Append(", product: ").Append(kDeviceLocalizedName); DEBUG(sb);
+            InputSystem.RegisterLayout(typeof(HandInteractionExtDevice),
+                kLayoutName,
+                matches: new InputDeviceMatcher()
+                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
+                    .WithProduct(kDeviceLocalizedName));
+        }
+
+        /// <summary>
+        /// Removes the <see cref="HandInteractionExtDevice"/> layout from the Input System.
+        /// </summary>
+        protected override void UnregisterDeviceLayout()
+        {
+            sb.Clear().Append("UnregisterDeviceLayout() ").Append(kLayoutName); DEBUG(sb);
+            InputSystem.RemoveLayout(kLayoutName);
+        }
+
+#if UNITY_XR_OPENXR_1_9_1
+        /// <summary>
+        /// Return interaction profile type. HandInteractionExtDevice profile is Device type.
+        /// </summary>
+        /// <returns>Interaction profile type.</returns>
+        protected override InteractionProfileType GetInteractionProfileType()
+        {
+            return typeof(HandInteractionExtDevice).IsSubclassOf(typeof(XRController)) ? InteractionProfileType.XRController : InteractionProfileType.Device;
+        }
+
+        /// <summary>
+        /// Return device layer out string used for registering device HandInteractionExtDevice in InputSystem.
+        /// </summary>
+        /// <returns>Device layout string.</returns>
+        protected override string GetDeviceLayoutName()
+        {
+            return kLayoutName;
+        }
+#endif
+
+        /// <summary>
+        /// Registers action maps to Unity XR.
+        /// </summary>
+        protected override void RegisterActionMapsWithRuntime()
+        {
+            sb.Clear().Append("RegisterActionMapsWithRuntime() Action map vivehandinteractionext")
+                .Append(", localizedName: ").Append(kDeviceLocalizedName)
+                .Append(", desiredInteractionProfile").Append(profile);
+            DEBUG(sb);
+
+            ActionMapConfig actionMap = new ActionMapConfig()
+            {
+                name = "vivehandinteractionext",
+                localizedName = kDeviceLocalizedName,
+                desiredInteractionProfile = profile,
+                manufacturer = "HTC",
+                serialNumber = "",
+                deviceInfos = new List<DeviceConfig>()
+                {
+                    new DeviceConfig()
+                    {
+                        characteristics = (InputDeviceCharacteristics)(InputDeviceCharacteristics.HandTracking | InputDeviceCharacteristics.HeldInHand | InputDeviceCharacteristics.TrackedDevice | InputDeviceCharacteristics.Left),
+                        userPath = UserPaths.leftHand
+                    },
+                    new DeviceConfig()
+                    {
+                        characteristics = (InputDeviceCharacteristics)(InputDeviceCharacteristics.HandTracking | InputDeviceCharacteristics.HeldInHand | InputDeviceCharacteristics.TrackedDevice | InputDeviceCharacteristics.Right),
+                        userPath = UserPaths.rightHand
+                    }
+                },
+                actions = new List<ActionConfig>()
+                {
+                    // Grip Pose
+                    new ActionConfig()
+                    {
+                        name = "devicePose",
+                        localizedName = "Grasp Pose",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Device"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = grip,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Grip Value
+                    new ActionConfig()
+                    {
+                        name = "graspValue",
+                        localizedName = "Grip Axis",
+                        type = ActionType.Axis1D,
+                        usages = new List<string>()
+                        {
+                            "GraspValue"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = graspValue,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Grip Ready
+					new ActionConfig()
+                    {
+                        name = "graspReady",
+                        localizedName = "Is Grasped",
+                        type = ActionType.Binary,
+                        usages = new List<string>()
+                        {
+                            "GraspReady"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = graspReady,
+                                interactionProfileName = profile,
+                            },
+                        }
+                    },
+					// Aim Pose
+					new ActionConfig()
+                    {
+                        name = "pointer",
+                        localizedName = "Aim Pose",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Pointer"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = aim,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Aim Value
+                    new ActionConfig()
+                    {
+                        name = "pointerActivateValue",
+                        localizedName = "Pointer Axis",
+                        type = ActionType.Axis1D,
+                        usages = new List<string>()
+                        {
+                            "PointerActivateValue"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pointerActivateValue,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+					// Aim Ready
+					new ActionConfig()
+                    {
+                        name = "pointerActivateReady",
+                        localizedName = "Is Pointed",
+                        type = ActionType.Binary,
+                        usages = new List<string>()
+                        {
+                            "PointerActivateReady"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pointerActivateReady,
+                                interactionProfileName = profile,
+                            },
+                        }
+                    },
+                    // Pinch Pose
+                    new ActionConfig()
+                    {
+                        name = "pinchPose",
+                        localizedName = "Pinch Pose",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Pinch"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pinchPose,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Pinch Value
+                    new ActionConfig()
+                    {
+                        name = "pinchValue",
+                        localizedName = "Pinch Axis",
+                        type = ActionType.Axis1D,
+                        usages = new List<string>()
+                        {
+                            "PinchValue"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pinchValue,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                    // Pinch Ready
+					new ActionConfig()
+                    {
+                        name = "pinchReady",
+                        localizedName = "Is Pinched",
+                        type = ActionType.Binary,
+                        usages = new List<string>()
+                        {
+                            "PinchReady"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = pinchReady,
+                                interactionProfileName = profile,
+                            },
+                        }
+                    },
+					// Poke Pose
+					new ActionConfig()
+                    {
+                        name = "pokePose",
+                        localizedName = "Index Tip",
+                        type = ActionType.Pose,
+                        usages = new List<string>()
+                        {
+                            "Poke"
+                        },
+                        bindings = new List<ActionBinding>()
+                        {
+                            new ActionBinding()
+                            {
+                                interactionPath = poke,
+                                interactionProfileName = profile,
+                            }
+                        }
+                    },
+                }
+            };
+
+            AddActionMap(actionMap);
+        }
+    }
+}

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Interaction/Scripts/ViveHandInteractionExt.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e1477dbc8916dff4f8e21fc343efcd46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c20ac17e6a9698a4ab9e7ac290153915
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Documentation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c3276899460ff6249b597e331d84b121
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Documentation/OpenXRExtensions.md

@@ -0,0 +1,48 @@
+# 12.28 XR_EXT_hand_tracking
+## Name String
+    XR_EXT_hand_tracking
+## Revision
+    4
+## New Object Types
+- [XrHandTrackerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerEXT)
+## New Enum Constants
+- [XR_HAND_JOINT_COUNT_EXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HAND_JOINT_COUNT_EXT)
+[XrObjectType](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrObjectType) enumeration is extended with:
+- XR_OBJECT_TYPE_HAND_TRACKER_EXT
+[XrStructureType](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrStructureType) enumeration is extended with:
+- XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT
+- XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT
+- XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT
+- XR_TYPE_HAND_JOINT_LOCATIONS_EXT
+- XR_TYPE_HAND_JOINT_VELOCITIES_EXT
+## New Enums
+- [XrHandEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandEXT)
+- [XrHandJointEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointEXT)
+- [XrHandJointSetEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointSetEXT)
+## New Structures
+- [XrSystemHandTrackingPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHandTrackingPropertiesEXT)
+- [XrHandTrackerCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerCreateInfoEXT)
+- [XrHandJointsLocateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsLocateInfoEXT)
+- [XrHandJointLocationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationEXT)
+- [XrHandJointVelocityEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocityEXT)
+- [XrHandJointLocationsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationsEXT)
+- [XrHandJointVelocitiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocitiesEXT)
+## New Functions
+- [xrCreateHandTrackerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateHandTrackerEXT)
+- [xrDestroyHandTrackerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyHandTrackerEXT)
+- [xrLocateHandJointsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrLocateHandJointsEXT)
+
+## VIVE Plugin
+
+After enabling the "VIVE Focus3 Hand Tracking" from "Project Settings > XR Plugin-in Management > OpenXR > Android Tab", you can retrieve the [XrHandJointLocationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationEXT) by using the following code.
+
+    using VIVE.OpenXR.Hand;
+
+    XrHandJointLocationEXT[] HandjointLocations = new XrHandJointLocationEXT[(int)XrHandJointEXT.XR_HAND_JOINT_MAX_ENUM_EXT];
+    var feature = OpenXRSettings.Instance.GetFeature<ViveHandTracking>();
+    if (feature && feature.GetJointLocations(isLeft, out HandjointLocations))
+    {
+        // now you have the hand joint data
+    }
+
+Refer to <VIVE OpenXR sample path>/Plugin/Input/Scripts/VIVE/RenderHand.cs about the sample code.

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Documentation/OpenXRExtensions.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 05f3bff8b2a4d0a4ea96ffedf619e30c
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a9ee0f2aa88738b47ab943ec3a3b52a7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Scripts/ViveHandProvider.cs

@@ -0,0 +1,458 @@
+using System.Collections.Generic;
+using Unity.Collections;
+using UnityEngine;
+using UnityEngine.XR;
+using UnityEngine.XR.OpenXR;
+using VIVE.OpenXR.Interaction;
+
+#if UNITY_XR_HANDS
+using UnityEngine.XR.Hands;
+using UnityEngine.XR.Hands.ProviderImplementation;
+namespace VIVE.OpenXR.Hand
+{
+    public class ViveHandProvider : XRHandSubsystemProvider
+    {
+        #region Hand Interaction
+        private const string kFeatureAimPos = "PointerPosition";
+        private const string kFeatureAimRot = "PointerRotation";
+        private const string kFeatureAimValue = "PointerActivateValue";
+        private const string kFeatureGripPos = "DevicePosition";
+        private const string kFeatureGripRot = "DeviceRotation";
+        private const string kFeatureGripValue = "GraspValue";
+        private const string kFeaturePinchPos = "PinchPosition";
+        private const string kFeaturePinchRot = "PinchRotation";
+        private const string kFeaturePinchValue = "PinchValue";
+        private const string kFeaturePokePos = "PokePosition";
+        private const string kFeaturePokeRot = "PokeRotation";
+
+        private class HandDevice
+        {
+            public Pose aimPose => m_AimPose;
+            public Pose gripPose => m_GripPose;
+            public Pose pinchPose => m_PinchPose;
+            public Pose pokePose => m_PokePose;
+            public float aimActivateValue => m_AimActivateValue;
+            public float graspValue => m_GraspValue;
+            public float pinchValue => m_PinchValue;
+
+            private Pose m_AimPose = Pose.identity;
+            private Pose m_GripPose = Pose.identity;
+            private Pose m_PinchPose = Pose.identity;
+            private Pose m_PokePose = Pose.identity;
+            private float m_AimActivateValue = 0;
+            private float m_GraspValue = 0;
+            private float m_PinchValue = 0;
+
+            private InputDevice device = default(InputDevice);
+            private Dictionary<string, InputFeatureUsage<Vector3>> posUsageMapping = new Dictionary<string, InputFeatureUsage<Vector3>>();
+            private Dictionary<string, InputFeatureUsage<Quaternion>> rotUsageMapping = new Dictionary<string, InputFeatureUsage<Quaternion>>();
+            private Dictionary<string, InputFeatureUsage<float>> valueUsageMapping = new Dictionary<string, InputFeatureUsage<float>>();
+
+            public HandDevice(InputDevice device)
+            {
+                this.device = device;
+
+                List<InputFeatureUsage> inputFeatures = new List<InputFeatureUsage>();
+                device.TryGetFeatureUsages(inputFeatures);
+                for (int i = 0; i < inputFeatures.Count; i++)
+                {
+                    InputFeatureUsage feature = inputFeatures[i];
+                    switch (feature.name)
+                    {
+                        case kFeatureAimPos:
+                        case kFeatureGripPos:
+                        case kFeaturePinchPos:
+                        case kFeaturePokePos:
+                            posUsageMapping.Add(feature.name, feature.As<Vector3>());
+                            break;
+                        case kFeatureAimRot:
+                        case kFeatureGripRot:
+                        case kFeaturePinchRot:
+                        case kFeaturePokeRot:
+                            rotUsageMapping.Add(feature.name, feature.As<Quaternion>());
+                            break;
+                        case kFeatureAimValue:
+                        case kFeatureGripValue:
+                        case kFeaturePinchValue:
+                            valueUsageMapping.Add(feature.name, feature.As<float>());
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            public void UpdateInputValue()
+            {
+                UpdatePosition();
+                UpdateRotation();
+                UpdateValue();
+            }
+
+            private void UpdatePosition()
+            {
+                var enumerator = posUsageMapping.GetEnumerator();
+                while (enumerator.MoveNext())
+                {
+                    var feature = enumerator.Current;
+                    string featureName = feature.Key;
+                    InputFeatureUsage<Vector3> featureUsage = feature.Value;
+                    if (device.TryGetFeatureValue(featureUsage, out Vector3 position))
+                    {
+                        switch (featureName)
+                        {
+                            case kFeatureAimPos:
+                                m_AimPose.position = position;
+                                break;
+                            case kFeatureGripPos:
+                                m_GripPose.position = position;
+                                break;
+                            case kFeaturePinchPos:
+                                m_PinchPose.position = position;
+                                break;
+                            case kFeaturePokePos:
+                                m_PokePose.position = position;
+                                break;
+                        }
+                    }
+                }
+            }
+
+            private void UpdateRotation() 
+            {
+                var enumerator = rotUsageMapping.GetEnumerator();
+                while (enumerator.MoveNext())
+                {
+                    var feature = enumerator.Current;
+                    string featureName = feature.Key;
+                    InputFeatureUsage<Quaternion> featureUsage = feature.Value;
+                    if (device.TryGetFeatureValue(featureUsage, out Quaternion rotation))
+                    {
+                        switch (featureName)
+                        {
+                            case kFeatureAimRot:
+                                m_AimPose.rotation = rotation;
+                                break;
+                            case kFeatureGripRot:
+                                m_GripPose.rotation = rotation;
+                                break;
+                            case kFeaturePinchRot:
+                                m_PinchPose.rotation = rotation;
+                                break;
+                            case kFeaturePokeRot:
+                                m_PokePose.rotation = rotation;
+                                break;
+                        }
+                    }
+                }
+            }
+
+            private void UpdateValue()
+            {
+                var enumerator = valueUsageMapping.GetEnumerator();
+                while (enumerator.MoveNext())
+                {
+                    var feature = enumerator.Current;
+                    string featureName = feature.Key;
+                    InputFeatureUsage<float> featureUsage = feature.Value;
+                    if (device.TryGetFeatureValue(featureUsage, out float value))
+                    {
+                        switch (featureName)
+                        {
+                            case kFeatureAimValue:
+                                m_AimActivateValue = value;
+                                break;
+                            case kFeatureGripValue:
+                                m_GraspValue = value;
+                                break;
+                            case kFeaturePinchValue:
+                                m_PinchValue = value;
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        private static HandDevice leftHandDevice = null;
+        private static HandDevice rightHandDevice = null;
+        private const string kInteractionDeviceName = "Vive Hand Interaction Ext OpenXR";
+        #endregion
+
+        private ViveHandTracking viveHand;
+
+        public override void Destroy() { }
+
+        public override void GetHandLayout(NativeArray<bool> handJointsInLayout)
+        {
+            handJointsInLayout[XRHandJointID.Palm.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.Wrist.ToIndex()] = true;
+
+            handJointsInLayout[XRHandJointID.ThumbMetacarpal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.ThumbProximal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.ThumbDistal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.ThumbTip.ToIndex()] = true;
+
+            handJointsInLayout[XRHandJointID.IndexMetacarpal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.IndexProximal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.IndexIntermediate.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.IndexDistal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.IndexTip.ToIndex()] = true;
+
+            handJointsInLayout[XRHandJointID.MiddleMetacarpal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.MiddleProximal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.MiddleIntermediate.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.MiddleDistal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.MiddleTip.ToIndex()] = true;
+
+            handJointsInLayout[XRHandJointID.RingMetacarpal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.RingProximal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.RingIntermediate.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.RingDistal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.RingTip.ToIndex()] = true;
+
+            handJointsInLayout[XRHandJointID.LittleMetacarpal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.LittleProximal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.LittleIntermediate.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.LittleDistal.ToIndex()] = true;
+            handJointsInLayout[XRHandJointID.LittleTip.ToIndex()] = true;
+        }
+
+        public override void Start()
+        {
+            Initialize();
+#if UNITY_XR_HANDS_1_5_0
+            InitHandInteractionDevices();
+            InputDevices.deviceConnected += DeviceConnected;
+            InputDevices.deviceDisconnected += DeviceDisconnected;
+#endif
+        }
+
+        public override void Stop()
+        {
+#if UNITY_XR_HANDS_1_5_0
+            InputDevices.deviceConnected -= DeviceConnected;
+            InputDevices.deviceDisconnected -= DeviceDisconnected;
+#endif
+        }
+
+        public override XRHandSubsystem.UpdateSuccessFlags TryUpdateHands(XRHandSubsystem.UpdateType updateType, ref Pose leftHandRootPose, NativeArray<XRHandJoint> leftHandJoints, ref Pose rightHandRootPose, NativeArray<XRHandJoint> rightHandJoints)
+        {
+            XRHandSubsystem.UpdateSuccessFlags flags = XRHandSubsystem.UpdateSuccessFlags.None;
+            if (UpdateHand(true, ref leftHandRootPose, ref leftHandJoints))
+            {
+                flags |= XRHandSubsystem.UpdateSuccessFlags.LeftHandRootPose | XRHandSubsystem.UpdateSuccessFlags.LeftHandJoints;
+            }
+            if (UpdateHand(false, ref rightHandRootPose, ref rightHandJoints))
+            {
+                flags |= XRHandSubsystem.UpdateSuccessFlags.RightHandRootPose | XRHandSubsystem.UpdateSuccessFlags.RightHandJoints;
+            }
+#if UNITY_XR_HANDS_1_5_0
+            if (updateType == XRHandSubsystem.UpdateType.Dynamic && canSurfaceCommonPoseData)
+            {
+                UpdateHandInteraction();
+            }
+#endif
+            return flags;
+        }
+
+#if UNITY_XR_HANDS_1_5_0
+        public override bool canSurfaceCommonPoseData => HandInteractionSupport();
+
+        public override bool TryGetAimPose(Handedness handedness, out Pose aimPose)
+        {
+            aimPose = Pose.identity;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                aimPose = handDevice.aimPose;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TryGetAimActivateValue(Handedness handedness, out float aimActivateValue)
+        {
+            aimActivateValue = 0;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                aimActivateValue = handDevice.aimActivateValue;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TryGetGripPose(Handedness handedness, out Pose gripPose)
+        {
+            gripPose = Pose.identity;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                gripPose = handDevice.gripPose;
+                return true;
+            }
+
+            return false;
+        }
+
+        public override bool TryGetGraspValue(Handedness handedness, out float graspValue)
+        {
+            graspValue = 0;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                graspValue = handDevice.graspValue;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TryGetPinchPose(Handedness handedness, out Pose pinchPose)
+        {
+            pinchPose = Pose.identity;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                pinchPose = handDevice.pinchPose;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TryGetPinchValue(Handedness handedness, out float pinchValue)
+        {
+            pinchValue = 0;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                pinchValue = handDevice.pinchValue;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TryGetPokePose(Handedness handedness, out Pose pokePose)
+        {
+            pokePose = Pose.identity;
+            HandDevice handDevice = GetHandDevice(handedness);
+            if (handDevice != null)
+            {
+                pokePose = handDevice.pokePose;
+                return true;
+            }
+            return false;
+        }
+
+        private void DeviceConnected(InputDevice inputDevice)
+        {
+            if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Left) &&
+                inputDevice.name == kInteractionDeviceName)
+            {
+                leftHandDevice = new HandDevice(inputDevice);
+            }
+            if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Right) &&
+                inputDevice.name == kInteractionDeviceName)
+            {
+                rightHandDevice = new HandDevice(inputDevice);
+            }
+        }
+
+        private void DeviceDisconnected(InputDevice inputDevice)
+        {
+            if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Left) &&
+                inputDevice.name == kInteractionDeviceName)
+            {
+                leftHandDevice = default;
+            }
+            if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Right) &&
+                inputDevice.name == kInteractionDeviceName)
+            {
+                rightHandDevice = default;
+            }
+        }
+
+        private void InitHandInteractionDevices()
+        {
+            List<InputDevice> inputDevices = new List<InputDevice>();
+            InputDevices.GetDevicesWithCharacteristics(InputDeviceCharacteristics.HeldInHand |
+                                                       InputDeviceCharacteristics.HandTracking |
+                                                       InputDeviceCharacteristics.TrackedDevice, inputDevices);
+            for (int i = 0; i < inputDevices.Count; i++)
+            {
+                InputDevice inputDevice = inputDevices[i];
+                DeviceConnected(inputDevice);
+            }
+        }
+
+        private void UpdateHandInteraction()
+        {
+            if (leftHandDevice != null)
+            {
+                leftHandDevice.UpdateInputValue();
+            }
+            if (rightHandDevice != null)
+            {
+                rightHandDevice.UpdateInputValue();
+            }
+        }
+
+        private HandDevice GetHandDevice(Handedness handedness) => handedness == Handedness.Left ? leftHandDevice : rightHandDevice;
+
+        private bool HandInteractionSupport()
+        {
+            ViveInteractions viveInteractions = OpenXRSettings.Instance.GetFeature<ViveInteractions>();
+            if (viveInteractions.enabled)
+            {
+                return viveInteractions.UseKhrHandInteraction();
+            }
+            return false;
+        }
+#endif
+
+        private void Initialize()
+        {
+            viveHand = OpenXRSettings.Instance.GetFeature<ViveHandTracking>();
+        }
+
+        private bool UpdateHand(bool isLeft, ref Pose handRootPose, ref NativeArray<XRHandJoint> handJoints)
+        {
+            if (!viveHand) { return false; }
+            bool isValid = viveHand.GetJointLocations(isLeft, out XrHandJointLocationEXT[] viveJoints);
+
+            Handedness handedness = isLeft ? Handedness.Left : Handedness.Right;
+            XRHandJointTrackingState trackingState = XRHandJointTrackingState.None;
+            for (int jointIndex = XRHandJointID.BeginMarker.ToIndex(); jointIndex < XRHandJointID.EndMarker.ToIndex(); ++jointIndex)
+            {
+                XRHandJointID jointID = XRHandJointIDUtility.FromIndex(jointIndex);
+                int viveIndex = XRHandJointIDToIndex(jointID);
+
+                Pose pose = Pose.identity;
+                if (isValid)
+                {
+                    pose.position = viveJoints[viveIndex].pose.position.ToUnityVector();
+                    pose.rotation = viveJoints[viveIndex].pose.orientation.ToUnityQuaternion();
+                    trackingState = XRHandJointTrackingState.Pose;
+                }
+                handJoints[jointIndex] = XRHandProviderUtility.CreateJoint(handedness, trackingState, jointID, pose);
+            }
+            handJoints[XRHandJointID.Wrist.ToIndex()].TryGetPose(out handRootPose);
+            return isValid;
+        }
+
+        private int XRHandJointIDToIndex(XRHandJointID id)
+        {
+            switch (id)
+            {
+                case XRHandJointID.Palm:
+                    return 0;
+                case XRHandJointID.Wrist:
+                    return 1;
+                default:
+                    return (int)id - 1;
+            }
+        }
+    }
+}
+#endif
+

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Scripts/ViveHandProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68f6a3e78d49e1143a9aa0a111a04a0a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.htc.upm.vive.openxr/Runtime/Features/Hand/Tracking/Scripts/ViveHandSubsystem.cs

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.XR.OpenXR;
+using VIVE.OpenXR.Interaction;
+
+#if UNITY_XR_HANDS
+using UnityEngine.XR.Hands;
+using UnityEngine.XR.Hands.ProviderImplementation;
+namespace VIVE.OpenXR.Hand
+{
+    public class ViveHandSubsystem : XRHandSubsystem
+    {
+        public const string featureId = "vive.openxr.feature.xrhandsubsystem";
+        private static XRHandSubsystem subsystem = null;
+        private XRHandProviderUtility.SubsystemUpdater subsystemUpdater = null;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void RegisterDescriptor()
+        {
+            if (!ViveHandTrackingSupport()) { return; }
+            bool handInteractionSupport = HandInteractionSupport();
+
+            var handsSubsystemCinfo = new XRHandSubsystemDescriptor.Cinfo
+            {
+                id = featureId,
+                providerType = typeof(ViveHandProvider),
+                subsystemTypeOverride = typeof(ViveHandSubsystem),
+#if UNITY_XR_HANDS_1_5_0
+                supportsAimPose = handInteractionSupport,
+                supportsAimActivateValue = handInteractionSupport,
+                supportsGraspValue = handInteractionSupport,
+                supportsGripPose = handInteractionSupport,
+                supportsPinchPose = handInteractionSupport,
+                supportsPinchValue = handInteractionSupport,
+                supportsPokePose = handInteractionSupport,
+#endif
+            };
+            XRHandSubsystemDescriptor.Register(handsSubsystemCinfo);
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void StartSubsystem()
+        {
+            List<XRHandSubsystemDescriptor> descriptors = new List<XRHandSubsystemDescriptor>();
+            if (subsystem == null || !subsystem.running)
+            {
+                descriptors.Clear();
+                SubsystemManager.GetSubsystemDescriptors(descriptors);
+                for (int i = 0; i < descriptors.Count; i++)
+                {
+                    XRHandSubsystemDescriptor descriptor = descriptors[i];
+                    if (descriptor.id == featureId)
+                    {
+                        subsystem = descriptor.Create();
+                        subsystem.Start();
+                    }
+                }
+            }
+        }
+
+        protected override void OnStart()
+        {
+            base.OnStart();
+            if (subsystemUpdater == null)
+            {
+                subsystemUpdater = new XRHandProviderUtility.SubsystemUpdater(subsystem);
+            }
+            subsystemUpdater.Start();
+
+        }
+
+        protected override void OnStop()
+        {
+            base.OnStop();
+            subsystemUpdater.Stop();
+        }
+
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+            subsystemUpdater.Destroy();
+            subsystemUpdater = null;
+        }
+
+        private static bool ViveHandTrackingSupport()
+        {
+            ViveHandTracking viveHand = OpenXRSettings.Instance.GetFeature<ViveHandTracking>();
+            return viveHand.enabled;
+        }
+
+        private static bool HandInteractionSupport()
+        {
+            ViveInteractions viveInteractions = OpenXRSettings.Instance.GetFeature<ViveInteractions>();
+            if (viveInteractions.enabled)
+            {
+                return viveInteractions.UseKhrHandInteraction();
+            }
+            return false;
+        }
+    }
+}
+#endif