version 2.3.0

com.htc.upm.vive.openxr/Runtime/Common/ViveFeatureCommonWrapper.cs

@@ -0,0 +1,140 @@
+// Copyright HTC Corporation All Rights Reserved.
+
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace VIVE.OpenXR.Feature
+{
+    /// <summary>
+    /// To use this wrapper, you need to call CommonWrapper.Instance.OnInstanceCreate() in your feature's OnInstanceCreate(), 
+    /// and call CommonWrapper.Instance.OnInstanceDestroy() in your feature's OnInstanceDestroy().
+    /// </summary>
+    public class CommonWrapper
+    {
+        static CommonWrapper instance = null;
+        public static CommonWrapper Instance
+        {
+            get
+            {
+                if (instance == null)
+                    instance = new CommonWrapper();
+                return instance;
+            }
+        }
+
+        bool isInited = false;
+
+        OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
+        OpenXRHelper.xrGetSystemPropertiesDelegate XrGetSystemProperties;
+
+        /// <summary>
+        /// In feature's OnInstanceCreate(), call CommonWrapper.Instance.OnInstanceCreate() for init common APIs.
+        /// </summary>
+        /// <param name="xrInstance">Passed in feature's OnInstanceCreate.</param>
+        /// <param name="xrGetInstanceProcAddr">Pass OpenXRFeature.xrGetInstanceProcAddr in.</param>
+        /// <returns></returns>
+        /// <exception cref="Exception">If input data not valid.</exception>
+        public bool OnInstanceCreate(XrInstance xrInstance, IntPtr xrGetInstanceProcAddr)
+        {
+            if (isInited) return true;
+
+            if (xrInstance == 0)
+                throw new Exception("CommonWrapper: xrInstance is null");
+
+            Debug.Log("CommonWrapper: OnInstanceCreate()");
+            /// OpenXRFeature.xrGetInstanceProcAddr
+            if (xrGetInstanceProcAddr == null || xrGetInstanceProcAddr == IntPtr.Zero)
+                throw new Exception("CommonWrapper: xrGetInstanceProcAddr is null");
+
+            Debug.Log("CommonWrapper: Get function pointer of xrGetInstanceProcAddr.");
+            XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
+                xrGetInstanceProcAddr,
+                typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
+
+            bool ret = true;
+            IntPtr funcPtr = IntPtr.Zero;
+
+            ret &= OpenXRHelper.GetXrFunctionDelegate(XrGetInstanceProcAddr, xrInstance, "xrGetSystemProperties", out XrGetSystemProperties);
+
+            if (!ret)
+                throw new Exception("CommonWrapper: Get function pointers failed.");
+
+            isInited = ret;
+            return ret;
+        }
+
+        /// <summary>
+        /// In feature's OnInstanceDestroy(), call CommonWrapper.Instance.OnInstanceDestroy() for disable common APIs.
+        /// </summary>
+        /// <returns></returns>
+        public void OnInstanceDestroy()
+        {
+            isInited = false;
+            XrGetInstanceProcAddr = null;
+            XrGetSystemProperties = null;
+            Debug.Log("CommonWrapper: OnInstanceDestroy()");
+        }
+
+        public XrResult GetInstanceProcAddr(XrInstance instance, string name, out IntPtr function)
+        {
+            if (isInited == false || XrGetInstanceProcAddr == null)
+            {
+                function = IntPtr.Zero;
+                return XrResult.XR_ERROR_HANDLE_INVALID;
+            }
+
+            return XrGetInstanceProcAddr(instance, name, out function);
+        }
+
+        /// <summary>
+        /// Helper function to get system properties.  Need input your features' xrInstance and xrSystemId.  Fill the system properites in next for you feature.
+        /// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>
+        /// </summary>
+        /// <param name="instance"></param>
+        /// <param name="systemId"></param>
+        /// <param name="properties"></param>
+        /// <returns></returns>
+        public XrResult GetSystemProperties(XrInstance instance, XrSystemId systemId, ref XrSystemProperties properties)
+        {
+            if (isInited == false || XrGetSystemProperties == null)
+            {
+                return XrResult.XR_ERROR_HANDLE_INVALID;
+            }
+
+            return XrGetSystemProperties(instance, systemId, ref properties);
+        }
+
+
+        public XrResult GetProperties<T>(XrInstance instance, XrSystemId systemId, ref T featureProperty)
+        {
+            XrSystemProperties systemProperties = new XrSystemProperties();
+            systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
+            systemProperties.next = Marshal.AllocHGlobal(Marshal.SizeOf(featureProperty));
+
+            long offset = 0;
+            if (IntPtr.Size == 4)
+                offset = systemProperties.next.ToInt32();
+            else
+                offset = systemProperties.next.ToInt64();
+
+            IntPtr pdPropertiesPtr = new IntPtr(offset);
+            Marshal.StructureToPtr(featureProperty, pdPropertiesPtr, false);
+
+            var ret = GetSystemProperties(instance, systemId, ref systemProperties);
+            if (ret == XrResult.XR_SUCCESS)
+            {
+                if (IntPtr.Size == 4)
+                    offset = systemProperties.next.ToInt32();
+                else
+                    offset = systemProperties.next.ToInt64();
+
+                pdPropertiesPtr = new IntPtr(offset);
+                featureProperty = Marshal.PtrToStructure<T>(pdPropertiesPtr);
+            }
+
+            Marshal.FreeHGlobal(systemProperties.next);
+            return ret;
+        }
+    }
+}