version 2.3.0

Author: Sean Lu(呂祥榮)

com.htc.upm.vive.openxr/Editor/CompositionLayer/Scripts/CompositionLayerEditor.cs

@@ -75,6 +75,11 @@ public class CompositionLayerEditor : Editor
 		static GUIContent Label_ApplyColorScaleBias = new GUIContent("Apply Color Scale Bias", "Color scale and bias are applied to a layer color during composition, after its conversion to premultiplied alpha representation. LayerColor = LayerColor * colorScale + colorBias");
 		SerializedProperty Property_ApplyColorScaleBias;
 
+		static string PropertyName_SolidEffect = "solidEffect";
+		static GUIContent Label_SolidEffect = new GUIContent("Solid Effect", "Apply UnderLay Color Scale Bias in Runtime Level.");
+		SerializedProperty Property_SolidEffect;
+
+
 		static string PropertyName_ColorScale = "colorScale";
 		static GUIContent Label_ColorScale = new GUIContent("Color Scale", "Will be used for modulatting the color sourced from the images.");
 		SerializedProperty Property_ColorScale;
@@ -114,6 +119,7 @@ public override void OnInspectorGUI()
 			if (Property_AngleOfArc == null) Property_AngleOfArc = serializedObject.FindProperty(PropertyName_AngleOfArc);
 			if (Property_IsDynamicLayer == null) Property_IsDynamicLayer = serializedObject.FindProperty(PropertyName_IsDynamicLayer);
 			if (Property_ApplyColorScaleBias == null) Property_ApplyColorScaleBias = serializedObject.FindProperty(PropertyName_ApplyColorScaleBias);
+			if (Property_SolidEffect == null) Property_SolidEffect = serializedObject.FindProperty(PropertyName_SolidEffect);
 			if (Property_ColorScale == null) Property_ColorScale = serializedObject.FindProperty(PropertyName_ColorScale);
 			if (Property_ColorBias == null) Property_ColorBias = serializedObject.FindProperty(PropertyName_ColorBias);
 			if (Property_IsProtectedSurface == null) Property_IsProtectedSurface = serializedObject.FindProperty(PropertyName_IsProtectedSurface);
@@ -441,6 +447,11 @@ public override void OnInspectorGUI()
 				}
 
 				EditorGUI.indentLevel++;
+				if (targetCompositionLayer.layerType == CompositionLayer.LayerType.Underlay)
+				{
+					EditorGUILayout.PropertyField(Property_SolidEffect, Label_SolidEffect);
+					serializedObject.ApplyModifiedProperties();
+				}
 				showColorScaleBiasParams = EditorGUILayout.Foldout(showColorScaleBiasParams, "Color Scale Bias Parameters");
 				if (showColorScaleBiasParams)
 				{

com.htc.upm.vive.openxr/Editor/VIVEFocus3FeatureSet.cs

@@ -7,24 +7,26 @@
 namespace VIVE.OpenXR
 {
 	[OpenXRFeatureSet(
-	   FeatureIds = new string[] {
+		FeatureIds = new string[] {
 			VIVEFocus3Feature.featureId,
 			VIVEFocus3Profile.featureId,
 			Hand.ViveHandTracking.featureId,
-			"vive.vive.openxr.feature.compositionlayer",
-			"vive.vive.openxr.feature.compositionlayer.cylinder",
-			"vive.vive.openxr.feature.compositionlayer.colorscalebias",
+			"vive.openxr.feature.compositionlayer",
+			"vive.openxr.feature.compositionlayer.cylinder",
+			"vive.openxr.feature.compositionlayer.colorscalebias",
 			Tracker.ViveWristTracker.featureId,
 			Hand.ViveHandInteraction.featureId,
-			"vive.vive.openxr.feature.foveation",
+			"vive.openxr.feature.foveation",
 			FacialTracking.ViveFacialTracking.featureId,
-		   },
-	   UiName = "VIVE XR Support",
-	   Description = "Necessary to deploy an VIVE XR compatible app.",
-	   FeatureSetId = "com.htc.vive.openxr.featureset.vivexr",
-	   DefaultFeatureIds = new string[] { VIVEFocus3Feature.featureId, VIVEFocus3Profile.featureId, },
-	   SupportedBuildTargets = new BuildTargetGroup[] { BuildTargetGroup.Android }
-   )]
+			PlaneDetection.VivePlaneDetection.featureId,
+			Anchor.ViveAnchor.featureId,
+		},
+		UiName = "VIVE XR Support",
+		Description = "Necessary to deploy an VIVE XR compatible app.",
+		FeatureSetId = "com.htc.vive.openxr.featureset.vivexr",
+		DefaultFeatureIds = new string[] { VIVEFocus3Feature.featureId, VIVEFocus3Profile.featureId, },
+		SupportedBuildTargets = new BuildTargetGroup[] { BuildTargetGroup.Android }
+	)]
 	sealed class VIVEFocus3FeatureSet { }
 }
 #endif

com.htc.upm.vive.openxr/Samples~/Samples/Samples/HandTracking.meta renamed to com.htc.upm.vive.openxr/Runtime/Common.meta

@@ -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;
+        }
+    }
+}