version 2.0.0

2023-09-14 18:17:47 +08:00
parent 13e9d00b37
commit ca21423a06
953 changed files with 125887 additions and 21229 deletions
--- a/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts.meta
+++ b/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: abf35aa708968a740b4565cdaa65ae7e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/SceneUnderstanding_OpenXR_API.cs
+++ b/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/SceneUnderstanding_OpenXR_API.cs
@@ -0,0 +1,345 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.XR.OpenXR.Features;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor.XR.OpenXR.Features;
+#endif
+
+namespace VIVE.OpenXR.SceneUnderstanding
+{
+#if UNITY_EDITOR
+    [OpenXRFeature(UiName = "VIVE XR Scene Understanding",
+        BuildTargetGroups = new[] { BuildTargetGroup.Standalone, BuildTargetGroup.WSA},
+        Company = "HTC",
+        Desc = "Get function pointers related to openxr scene understanding",
+        DocumentationLink = "https://developer.vive.com/resources/openxr/openxr-pcvr/tutorials/unity/interact-real-world-openxr-scene-understanding/",
+        OpenxrExtensionStrings = "XR_MSFT_scene_understanding",
+        Version = "0.0.1",
+        FeatureId = featureId)]
+#endif
+    public class SceneUnderstanding_OpenXR_API : OpenXRFeature
+    {
+        /// <summary>
+        /// The feature id string. This is used to give the feature a well known id for reference.
+        /// </summary>
+        public const string featureId = "com.htc.openxr.sceneunderstanding.feature";
+
+        #region OpenXR callbacks
+        protected override bool OnInstanceCreate(ulong xrInstance)
+        {
+            UnityEngine.Debug.Log($"OnInstanceCreate({xrInstance})");
+            m_XrInstance = xrInstance;
+
+            return GetXrFunctionDelegates(xrInstance);
+        }
+        protected override void OnInstanceDestroy(ulong xrInstance)
+        {
+            UnityEngine.Debug.Log($"OnInstanceDestroy({xrInstance})");
+        }
+        protected override void OnSessionCreate(ulong xrSession)
+        {
+            UnityEngine.Debug.Log($"OnSessionCreate({xrSession})");
+            m_XrSession = xrSession;
+            systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
+            int res = xrGetSystemProperties(ref systemProperties);
+            if (res != (int)XrResult.XR_SUCCESS)
+            {
+                UnityEngine.Debug.Log("Failed to get systemproperties with error code : " + res);
+
+            }
+        }
+        protected override void OnSystemChange(ulong xrSystem)
+        {
+            UnityEngine.Debug.Log($"OnSystemChange({xrSystem})");
+            m_systemid = xrSystem;
+        }
+        protected override void OnSessionDestroy(ulong xrSession)
+        {
+            UnityEngine.Debug.Log($"OnSessionDestroy({xrSession})");
+        }
+
+        bool CheckResult(XrResult result) => result == XrResult.XR_SUCCESS;
+        public bool GetXrFunctionDelegates(ulong xrInstance)
+        {
+            Debug.Log("GetXrFunctionDelegates() begin");
+            if (xrGetInstanceProcAddr == null || xrGetInstanceProcAddr == IntPtr.Zero)
+                UnityEngine.Debug.LogError("xrGetInstanceProcAddr is null");
+            // Get delegate of xrGetInstanceProcAddr.
+            m_XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer<xrGetInstanceProcDelegate>(xrGetInstanceProcAddr);
+            // Get delegate of other OpenXR functions using xrGetInstanceProcAddr.
+            bool successful = true;
+            IntPtr funcPtr = IntPtr.Zero;
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrGetSystemProperties function failed"); return false; }
+            m_xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(funcPtr, typeof(xrGetSystemPropertiesDelegate)) as xrGetSystemPropertiesDelegate;
+            if (m_xrGetSystemProperties == null) { Debug.Log("m_xrGetSystemProperties == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrEnumerateReferenceSpaces", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrEnumerateReferenceSpaces function failed"); return false; }
+            m_XrEnumerateReferenceSpaces = Marshal.GetDelegateForFunctionPointer<XrEnumerateReferenceSpacesDelegate>(funcPtr);
+            if (m_XrEnumerateReferenceSpaces == null) { Debug.Log("m_XrEnumerateReferenceSpaces == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrCreateReferenceSpace", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrCreateReferenceSpace function failed"); return false; }
+            m_XrCreateReferenceSpace = Marshal.GetDelegateForFunctionPointer<XrCreateReferenceSpaceDelegate>(funcPtr);
+            if (m_XrCreateReferenceSpace == null) { Debug.Log("m_XrCreateReferenceSpace == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrDestroySpace function failed"); return false; }
+            m_XrDestroySpace = Marshal.GetDelegateForFunctionPointer<XrDestroySpaceDelegate>(funcPtr);
+            if (m_XrDestroySpace == null) { Debug.Log("m_XrDestroySpace == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrEnumerateSceneComputeFeaturesMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrEnumerateSceneComputeFeaturesMSFT function failed"); return false; }
+            m_XrEnumerateSceneComputeFeaturesMSFT = Marshal.GetDelegateForFunctionPointer<XrEnumerateSceneComputeFeaturesMSFTDelegate>(funcPtr);
+            if (m_XrEnumerateSceneComputeFeaturesMSFT == null) { Debug.Log("m_XrEnumerateSceneComputeFeaturesMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrCreateSceneObserverMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrCreateSceneObserverMSFT function failed"); return false; }
+            m_XrCreateSceneObserverMSFT = Marshal.GetDelegateForFunctionPointer<XrCreateSceneObserverMSFTDelegate>(funcPtr);
+            if (m_XrCreateSceneObserverMSFT == null) { Debug.Log("m_XrCreateSceneObserverMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrDestroySceneObserverMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrDestroySceneObserverMSFT function failed"); return false; }
+            m_XrDestroySceneObserverMSFT = Marshal.GetDelegateForFunctionPointer<XrDestroySceneObserverMSFTDelegate>(funcPtr);
+            if (m_XrDestroySceneObserverMSFT == null) { Debug.Log("m_XrDestroySceneObserverMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrCreateSceneMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrCreateSceneMSFT function failed"); return false; }
+            m_XrCreateSceneMSFT = Marshal.GetDelegateForFunctionPointer<XrCreateSceneMSFTDelegate>(funcPtr);
+            if (m_XrCreateSceneMSFT == null) { Debug.Log("m_XrCreateSceneMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrDestroySceneMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrDestroySceneMSFT function failed"); return false; }
+            m_XrDestroySceneMSFT = Marshal.GetDelegateForFunctionPointer<XrDestroySceneMSFTDelegate>(funcPtr);
+            if (m_XrDestroySceneMSFT == null) { Debug.Log("m_XrDestroySceneMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrComputeNewSceneMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrComputeNewSceneMSFT function failed"); return false; }
+            m_XrComputeNewSceneMSFT = Marshal.GetDelegateForFunctionPointer<XrComputeNewSceneMSFTDelegate>(funcPtr);
+            if (m_XrComputeNewSceneMSFT == null) { Debug.Log("m_XrComputeNewSceneMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrGetSceneComputeStateMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrGetSceneComputeStateMSFT function failed"); return false; }
+            m_XrGetSceneComputeStateMSFT = Marshal.GetDelegateForFunctionPointer<XrGetSceneComputeStateMSFTDelegate>(funcPtr);
+            if (m_XrGetSceneComputeStateMSFT == null) { Debug.Log("m_XrGetSceneComputeStateMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrGetSceneComponentsMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrGetSceneComponentsMSFT function failed"); return false; }
+            m_XrGetSceneComponentsMSFT = Marshal.GetDelegateForFunctionPointer<XrGetSceneComponentsMSFTDelegate>(funcPtr);
+            if (m_XrGetSceneComponentsMSFT == null) { Debug.Log("m_XrGetSceneComponentsMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrLocateSceneComponentsMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrLocateSceneComponentsMSFT function failed"); return false; }
+            m_XrLocateSceneComponentsMSFT = Marshal.GetDelegateForFunctionPointer<XrLocateSceneComponentsMSFTDelegate>(funcPtr);
+            if (m_XrLocateSceneComponentsMSFT == null) { Debug.Log("m_XrLocateSceneComponentsMSFT == null"); }
+
+            successful &= CheckResult((XrResult)m_XrGetInstanceProcAddr(xrInstance, "xrGetSceneMeshBuffersMSFT", out funcPtr));
+            if (funcPtr == IntPtr.Zero) { UnityEngine.Debug.Log("Get xrGetSceneMeshBuffersMSFT function failed"); return false; }
+            m_XrGetSceneMeshBuffersMSFT = Marshal.GetDelegateForFunctionPointer<XrGetSceneMeshBuffersMSFTDelegate>(funcPtr);
+            if (m_XrGetSceneMeshBuffersMSFT == null) { Debug.Log("m_XrGetSceneMeshBuffersMSFT == null"); }
+
+            Debug.Log("GetXrFunctionDelegates() end");
+            return successful;
+        }
+        #endregion
+        public ulong m_XrInstance;
+        public ulong m_XrSession;
+        public ulong m_systemid;
+        public XrSystemProperties systemProperties;
+        xrGetInstanceProcDelegate m_XrGetInstanceProcAddr;
+
+        public delegate int xrGetSystemPropertiesDelegate(ulong instance, ulong systemId, ref XrSystemProperties properties);
+        public xrGetSystemPropertiesDelegate m_xrGetSystemProperties;
+        public int xrGetSystemProperties(ref XrSystemProperties properties) =>
+            m_xrGetSystemProperties(m_XrInstance, m_systemid, ref properties);
+
+        public delegate XrResult XrEnumerateReferenceSpacesDelegate(
+            ulong session,
+            uint spaceCapacityInput,
+            out int spaceCountOutput,
+            IntPtr spaces);
+        public XrEnumerateReferenceSpacesDelegate m_XrEnumerateReferenceSpaces;
+        public XrResult XrEnumerateReferenceSpaces(
+            uint spaceCapacityInput,
+            out int spaceCountOutput,
+            IntPtr spaces
+        ) => m_XrEnumerateReferenceSpaces(
+            m_XrSession,
+            spaceCapacityInput,
+            out spaceCountOutput,
+            spaces
+        );
+        public delegate XrResult XrCreateReferenceSpaceDelegate(
+            ulong session,
+            ref XrReferenceSpaceCreateInfo createInfo,
+            out ulong space);
+        public XrCreateReferenceSpaceDelegate m_XrCreateReferenceSpace;
+        public XrResult XrCreateReferenceSpace(
+            ref XrReferenceSpaceCreateInfo createInfo,
+            out ulong space
+        ) => m_XrCreateReferenceSpace(
+            m_XrSession,
+            ref createInfo,
+            out space
+        );
+        public delegate XrResult XrDestroySpaceDelegate(
+            ulong space);
+        public XrDestroySpaceDelegate m_XrDestroySpace;
+        public XrResult XrDestroySpace(
+            ulong space
+        ) => m_XrDestroySpace(
+            space
+        );
+
+        public delegate XrResult XrEnumerateSceneComputeFeaturesMSFTDelegate(
+            ulong instance,
+            ulong systemId,
+            uint featureCapacityInput,
+            out uint featureCountOutput,
+            IntPtr features
+        );
+        public XrEnumerateSceneComputeFeaturesMSFTDelegate m_XrEnumerateSceneComputeFeaturesMSFT;
+        public XrResult XrEnumerateSceneComputeFeaturesMSFT(
+            ulong systemId,
+            uint featureCapacityInput,
+            out uint featureCountOutput,
+            IntPtr features
+        ) => m_XrEnumerateSceneComputeFeaturesMSFT(
+            m_XrInstance,
+            systemId,
+            featureCapacityInput,
+            out featureCountOutput,
+            features
+        );
+        public delegate XrResult XrCreateSceneObserverMSFTDelegate(
+            ulong session,
+            ref XrSceneObserverCreateInfoMSFT createInfo,
+            out ulong sceneObserver
+        );
+        public XrCreateSceneObserverMSFTDelegate m_XrCreateSceneObserverMSFT;
+        public XrResult XrCreateSceneObserverMSFT(
+            ref XrSceneObserverCreateInfoMSFT createInfo,
+            out ulong sceneObserver
+        ) => m_XrCreateSceneObserverMSFT(
+            m_XrSession,
+            ref createInfo,
+            out sceneObserver
+        );
+
+        public delegate XrResult XrDestroySceneObserverMSFTDelegate(
+            ulong sceneObserver
+        );
+        public XrDestroySceneObserverMSFTDelegate m_XrDestroySceneObserverMSFT;
+        public XrResult XrDestroySceneObserverMSFT(
+            ulong sceneObserver
+        ) => m_XrDestroySceneObserverMSFT(
+            sceneObserver
+        );
+
+        public delegate XrResult XrCreateSceneMSFTDelegate(
+            ulong sceneObserver,
+            ref XrSceneCreateInfoMSFT createInfo,
+            out ulong scene
+        );
+        public XrCreateSceneMSFTDelegate m_XrCreateSceneMSFT;
+        public XrResult XrCreateSceneMSFT(
+            ulong sceneObserver,
+            ref XrSceneCreateInfoMSFT createInfo,
+            out ulong scene
+        ) => m_XrCreateSceneMSFT(
+            sceneObserver,
+            ref createInfo,
+            out scene
+        );
+
+        public delegate XrResult XrDestroySceneMSFTDelegate(
+            ulong scene
+        );
+        public XrDestroySceneMSFTDelegate m_XrDestroySceneMSFT;
+        public XrResult XrDestroySceneMSFT(
+            ulong scene
+        ) => m_XrDestroySceneMSFT(
+            scene
+        );
+
+        public delegate XrResult XrComputeNewSceneMSFTDelegate(
+            ulong sceneObserver,
+            ref XrNewSceneComputeInfoMSFT computeInfo
+        );
+        public XrComputeNewSceneMSFTDelegate m_XrComputeNewSceneMSFT;
+        public XrResult XrComputeNewSceneMSFT(
+            ulong sceneObserver,
+            ref XrNewSceneComputeInfoMSFT computeInfo
+        ) => m_XrComputeNewSceneMSFT(
+            sceneObserver,
+            ref computeInfo
+        );
+
+        public delegate XrResult XrGetSceneComputeStateMSFTDelegate(
+            ulong sceneObserver,
+            out XrSceneComputeStateMSFT state
+        );
+        public XrGetSceneComputeStateMSFTDelegate m_XrGetSceneComputeStateMSFT;
+        public XrResult XrGetSceneComputeStateMSFT(
+            ulong sceneObserver,
+            out XrSceneComputeStateMSFT state
+        ) => m_XrGetSceneComputeStateMSFT(
+            sceneObserver,
+            out state
+        );
+
+        public delegate XrResult XrGetSceneComponentsMSFTDelegate(
+            ulong scene,
+            ref XrSceneComponentsGetInfoMSFT getInfo,
+            ref XrSceneComponentsMSFT components
+        );
+        public XrGetSceneComponentsMSFTDelegate m_XrGetSceneComponentsMSFT;
+        public XrResult XrGetSceneComponentsMSFT(
+            ulong scene,
+            ref XrSceneComponentsGetInfoMSFT getInfo,
+            ref XrSceneComponentsMSFT components
+        ) => m_XrGetSceneComponentsMSFT(
+            scene,
+            ref getInfo,
+            ref components
+        );
+
+        public delegate XrResult XrLocateSceneComponentsMSFTDelegate(
+            ulong scene,
+            ref XrSceneComponentsLocateInfoMSFT locateInfo,
+            ref XrSceneComponentLocationsMSFT locations
+        );
+        public XrLocateSceneComponentsMSFTDelegate m_XrLocateSceneComponentsMSFT;
+        public XrResult XrLocateSceneComponentsMSFT(
+            ulong scene,
+            ref XrSceneComponentsLocateInfoMSFT locateInfo,
+            ref XrSceneComponentLocationsMSFT locations
+        ) => m_XrLocateSceneComponentsMSFT(
+            scene,
+            ref locateInfo,
+            ref locations
+        );
+
+        public delegate XrResult XrGetSceneMeshBuffersMSFTDelegate(
+            ulong scene,
+            ref XrSceneMeshBuffersGetInfoMSFT getInfo,
+            ref XrSceneMeshBuffersMSFT buffers
+        );
+        public XrGetSceneMeshBuffersMSFTDelegate m_XrGetSceneMeshBuffersMSFT;
+        public XrResult XrGetSceneMeshBuffersMSFT(
+            ulong scene,
+            ref XrSceneMeshBuffersGetInfoMSFT getInfo,
+            ref XrSceneMeshBuffersMSFT buffers
+        ) => m_XrGetSceneMeshBuffersMSFT(
+            scene,
+            ref getInfo,
+            ref buffers
+        );
+
+    }
+}
--- a/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/SceneUnderstanding_OpenXR_API.cs.meta
+++ b/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/SceneUnderstanding_OpenXR_API.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f11d54adfd486544afef5e8b85f159d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/ViveSceneUnderstandingHelper.cs
+++ b/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/ViveSceneUnderstandingHelper.cs
@@ -0,0 +1,387 @@
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace VIVE.OpenXR.SceneUnderstanding
+{
+    public enum XrSceneComputeConsistencyMSFT
+    {
+        SnapshotComplete = 1,
+        SnapshotIncompleteFast = 2,
+        OcclusionOptimized = 3,
+    }
+
+    public enum XrSceneBoundType
+    {
+        Sphere = 1,
+        OrientedBox = 2,
+        Frustum = 3,
+    }
+
+    public enum XrSceneComputeFeatureMSFT
+    {
+        XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT = 1,
+        XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT = 2,
+        XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT = 3,
+        XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT = 4,
+        XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT = 1000098000,
+        XR_SCENE_COMPUTE_FEATURE_OCCLUSION_HINT_MSFT = 1000099000,
+        XR_SCENE_COMPUTE_FEATURE_MAX_ENUM_MSFT = 0x7FFFFFFF
+    }
+
+    public enum XrMeshComputeLodMSFT
+    {
+        Coarse = 1,
+        Medium = 2,
+        Fine = 3,
+        Unlimited = 4,
+    }
+
+    public enum XrSceneComponentTypeMSFT
+    {
+        XR_SCENE_COMPONENT_TYPE_INVALID_MSFT = -1,
+        XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT = 1,
+        XR_SCENE_COMPONENT_TYPE_PLANE_MSFT = 2,
+        XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT = 3,
+        XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT = 4,
+        XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT = 1000098000,
+        XR_SCENE_COMPONENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+    }
+
+    public enum XrSceneObjectTypeMSFT
+    {
+        XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT = -1,
+        XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT = 1,
+        XR_SCENE_OBJECT_TYPE_WALL_MSFT = 2,
+        XR_SCENE_OBJECT_TYPE_FLOOR_MSFT = 3,
+        XR_SCENE_OBJECT_TYPE_CEILING_MSFT = 4,
+        XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT = 5,
+        XR_SCENE_OBJECT_TYPE_INFERRED_MSFT = 6,
+        XR_SCENE_OBJECT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+    }
+
+    public enum XrScenePlaneAlignmentTypeMSFT
+    {
+        XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT = 0,
+        XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT = 1,
+        XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT = 2,
+        XR_SCENE_PLANE_ALIGNMENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+    }
+
+    public enum XrSceneComputeStateMSFT
+    {
+        XR_SCENE_COMPUTE_STATE_NONE_MSFT = 0,
+        XR_SCENE_COMPUTE_STATE_UPDATING_MSFT = 1,
+        XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT = 2,
+        XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT = 3,
+        XR_SCENE_COMPUTE_STATE_MAX_ENUM_MSFT = 0x7FFFFFFF
+    }
+
+    public struct XrUuidMSFT
+    {
+        public byte byte0;
+        public byte byte1;
+        public byte byte2;
+        public byte byte3;
+        public byte byte4;
+        public byte byte5;
+        public byte byte6;
+        public byte byte7;
+        public byte byte8;
+        public byte byte9;
+        public byte byte10;
+        public byte byte11;
+        public byte byte12;
+        public byte byte13;
+        public byte byte14;
+        public byte byte15;
+        public byte byte16;
+
+    }
+
+    public struct XrSceneObserverCreateInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+    }
+
+    public struct XrSceneCreateInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+    }
+
+    public struct XrSceneSphereBoundMSFT
+    {
+        public XrVector3f center;
+        public float radius;
+    }
+
+    public struct XrSceneOrientedBoxBoundMSFT
+    {
+        public XrPosef pose;
+        public XrVector3f extents;
+    }
+
+    public struct XrSceneFrustumBoundMSFT
+    {
+        public XrPosef pose;
+        public XrFovf fov;
+        public float farDistance;
+    }
+
+    public struct XrSceneBoundsMSFT
+    {
+        public ulong space;
+        public long time;
+        public uint sphereCount;
+
+        // XrSceneSphereBoundMSFT
+        public IntPtr spheres;
+        public uint boxCount;
+
+        // XrSceneOrientedBoxBoundMSFT
+        public IntPtr boxes;
+        public uint frustumCount;
+
+        // XrSceneFrustumBoundMSFT
+        public IntPtr frustums;
+    }
+
+    public struct XrNewSceneComputeInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint requestedFeatureCount;
+
+        // XrSceneComputeFeatureMSFT array
+        public IntPtr requestedFeatures;
+        public uint disableInferredSceneObjects;
+        public XrSceneBoundsMSFT bounds;
+    }
+
+    // XrVisualMeshComputeLodInfoMSFT extends XrNewSceneComputeInfoMSFT
+    public struct XrVisualMeshComputeLodInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public XrMeshComputeLodMSFT lod;
+    }
+
+    public struct XrSceneComponentMSFT
+    {
+        public XrSceneComponentTypeMSFT componentType;
+        public XrUuidMSFT componentId;
+        public XrUuidMSFT parentObjectId;
+        public long updateTime;
+    }
+
+    public struct XrSceneComponentsMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint componentCapacityInput;
+        public uint componentCountOutput;
+
+        // XrSceneComponentMSFT array
+        public IntPtr components;
+    }
+
+    public struct XrSceneComponentsGetInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public XrSceneComponentTypeMSFT componentType;
+    }
+
+    public struct XrSceneComponentLocationMSFT
+    {
+        public ulong flags;
+        public XrPosef pose;
+    }
+
+    public struct XrSceneComponentLocationsMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint locationCount;
+
+        // XrSceneComponentLocationMSFT array
+        public IntPtr locations;
+    }
+
+    public struct XrSceneComponentsLocateInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+
+        // XrSpace
+        public ulong baseSpace;
+
+        // XrTime
+        public long time;
+        public uint idCount;
+
+        // XrUuidMSFT array
+        public IntPtr ids;
+    }
+
+    public struct XrSceneObjectMSFT
+    {
+        public XrSceneObjectTypeMSFT objectType;
+    }
+
+    // XrSceneObjectsMSFT extends XrSceneComponentsMSFT
+    public struct XrSceneObjectsMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint sceneObjectCount;
+
+        // XrSceneObjectMSFT array
+        public IntPtr sceneObjects;
+    }
+
+    // XrSceneComponentParentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+    public struct XrSceneComponentParentFilterInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public XrUuidMSFT parentObjectId;
+    }
+
+    // XrSceneObjectTypesFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+    public struct XrSceneObjectTypesFilterInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint objectTypeCount;
+
+        // XrSceneObjectTypeMSFT array
+        public IntPtr objectTypes;
+    }
+
+    public struct XrScenePlaneMSFT
+    {
+        public XrScenePlaneAlignmentTypeMSFT alignment;
+        public XrExtent2Df size;
+        public ulong meshBufferId;
+
+        // XrBool32
+        public uint supportsIndicesUint16;
+    }
+
+    // XrScenePlanesMSFT extends XrSceneComponentsMSFT
+    public struct XrScenePlanesMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint scenePlaneCount;
+
+        // XrScenePlaneMSFT array
+        public IntPtr scenePlanes;
+    }
+
+    // XrScenePlaneAlignmentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+    public struct XrScenePlaneAlignmentFilterInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint alignmentCount;
+
+        // XrScenePlaneAlignmentTypeMSFT array
+        public IntPtr alignments;
+    }
+
+    public struct XrSceneMeshMSFT
+    {
+        public ulong meshBufferId;
+
+        // XrBool32
+        public uint supportsIndicesUint16;
+    }
+
+    // XrSceneMeshesMSFT extends XrSceneComponentsMSFT
+    public struct XrSceneMeshesMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint sceneMeshCount;
+
+        // XrSceneMeshMSFT array
+        public IntPtr sceneMeshes;
+    }
+
+    public struct XrSceneMeshBuffersGetInfoMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public ulong meshBufferId;
+    }
+
+    public struct XrSceneMeshBuffersMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+    }
+
+    public struct XrSceneMeshVertexBufferMSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint vertexCapacityInput;
+        public uint vertexCountOutput;
+
+        // XrVector3f array
+        public IntPtr vertices;
+    }
+
+    public struct XrSceneMeshIndicesUint32MSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint indexCapacityInput;
+        public uint indexCountOutput;
+
+        // uint32_t array
+        public IntPtr indices;
+    }
+
+    public struct XrSceneMeshIndicesUint16MSFT
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint indexCapacityInput;
+        public uint indexCountOutput;
+
+        // uint16_t array
+        public IntPtr indices;
+    }
+
+    public struct XrSystemPassThroughCameraInfoHTC
+    {
+        public float focalLengthX;
+        public float focalLengthY;
+        public float opticalCenterX;
+        public float opticalCenterY;
+        public uint imageWidth;
+        public uint imageHeight;
+        public uint imageChannelCount;
+    }
+    public struct XrSystemPassThroughPropertiesHTC
+    {
+        public XrStructureType type;
+        public IntPtr next;
+        public uint supportsPassThrough;
+        XrSystemPassThroughCameraInfoHTC leftCameraInfo;
+        XrSystemPassThroughCameraInfoHTC rightCameraInfo;
+        public int deviceType;
+        public long format;
+    }
+
+    delegate int xrGetInstanceProcDelegate(ulong instance, string name, out IntPtr function);
+    public static class ViveSceneUnderstandingHelper
+    {
+
+    }
+}
--- a/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/ViveSceneUnderstandingHelper.cs.meta
+++ b/com.htc.upm.vive.openxr/Runtime/Features/SceneUnderstanding/Scripts/ViveSceneUnderstandingHelper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8e83b965a9b0fd4cbef91ba1bd5010d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: