slococo-uni
/
mixedreality
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add openxr package

This commit is contained in:
Santiago Lo Coco 2024-10-13 18:53:46 +02:00
commit eae9489ba8
225 changed files with 14557 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

382
com.microsoft.mixedreality.openxr/CHANGELOG.md Normal file
View File

@ -0,0 +1,382 @@
# Changelog
All notable changes to this package will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
## [1.11.1] - Current Release
* Upgraded the OpenXR remoting runtime to 2.9.4 release.
* Fixed a deadlock issue that occurred when the GPU encoder was occupied for long durations.
* Fixed erroneous pinch gap values leading to unwanted interactions.
* Added new `OpenXRTime` API that contains methods to predict display times.
* Added `TryReloadAnchorStoreAsync` method to `XRAnchorStore` which can be used to reload the anchor store when the map or anchors have been modified outside the application.
* Fixed instances of null propagation on Unity objects
## [1.11.0] - 2024-06-26
* Internal test release
## [1.10.1] - 2024-04-17
* Fixed a bug where RaycastSubsystem would search for a missing ARPlaneManager every frame.
* Fixed a bug where camera validation produced errors with no camera in the scene.
* Fixed a bug where the locatable camera was registered but not unregistered.
## [1.10.0] - 2023-12-04
* Added new APIs `TrackingMapManager` and `TrackingMapType` to allow an application to opt into running in an Application-Exclusive tracking mode on HoloLens 2.
* Upgraded the OpenXR remoting runtime to 2.9.3 release.
* Holographic Remoting using the OpenXR API now supports the XR_MSFT_scene_marker extension.
* Holographic Remoting using the OpenXR API now supports GPU Adapter selection through the XrRemotingPreferredGraphicsAdapterMSFT extension struct.
* Updated the OpenXR MR Plugin package to be compatible with Unity's UPM Asset Store.
* Fixed an issue where ARMarkerManager was getting enabled even when marker functionality was unavailable.
* Fixed an issue where ARMarkers were not positioned correctly for some orientations when using TransformMode.Center.
* Added additional context to MR Plugin validation tooltips.
## [1.9.0] - 2023-09-12
* Minimum requirement of Unity version is changed to Unity 2021.3 LTS.
* Added new APIs `ARMarkerManager`, `ARMarker` and others for QR code tracking on HoloLens 2.
* Added new API `AppRemoting.AudioCaptureMode` for remoting apps to choose audio capture mode between system-wide vs. within application.
* Added new APIs `AppRemoting.TryConvertToPlayerTime` and `AppRemoting.TryConvertToRemoteTime` to convert timestamp between remoting app and remoting player.
* Fixed a bug where the `AppRemoting.TryGetConnectionState` function sometimes did not return the correct `disconnectReason` when the session was unexpectedly lost.
* Added a new `Mixed Reality -> Project Setting Validations` menu to select 4 new rulesets to help users setup project settings easily for different types of Mixed Reality applications.
* The following APIs are deprecated and may be removed in future releases:
* Deprecated extension methods, such as `ARAnchorExtensions`, `XRAnchorExtensions`, and `MeshSubsystemExtensions`, in favor of their corresponding static functions.
* `EyeLevelSceneOrigin` is deprecated in favor of MRTK3 `Microsoft.MixedReality.Toolkit.Input.UnboundedTrackingMode` for HoloLens 2 application using unbounded space. For other XR applications use `Unity.​XR.​Core​Utils.XROrigin` instead.
## [1.8.1] - 2023-06-21
* Restored Android support for hand tracking and controller models.
* These features are now deprecated instead of entirely removed.
* Using the OpenXR plugins from Unity and Meta is still recommended for these features.
* Depends on version 1.8.0 of Unity's OpenXR plugin.
* Deprecated our HP Reverb G2 controller bindings in the Mixed Reality OpenXR plugin.
* Recommend using the equivalent HP Reverb G2 controller bindings in Unity's OpenXR plugin with version 1.8.0 or above.
* Fixed a bug which prevented apps from building for platforms where this plugin was included, but not in use.
* Fixed a bug where errors about plugin initialization were printed when the plugin was included, but not in use.
* Fixed a bug where the EyeLevelSceneOrigin script behaved incorrectly when running in a scene without XR started.
* Fixed a bug where using this plugin with Unity 2022 and ARFoundation 5 would cause warnings.
## [1.8.0] - 2023-04-04
* Removed Android related XR features for hand tracking and controller models.
* Recommend using the OpenXR plugin from Unity and Meta for these features.
* Upgraded the OpenXR remoting runtime to 2.9.1 release.
* Fixed a bug where ARPlaneManager does not report planes after some number of Unity PlayMode remoting sessions.
* Fixed a bug where anchors are not persisted after clearing the Anchor Store in Unity PlayMode remoting session.
* Fixed a bug where UWP project validation shows up incorrectly when OpenXR feature is disabled for HoloLens2.
* Fixed a bug where anchor creation failure leads to unnecessary spamming debugger logs.
* Fixed a bug that sometimes crashes an app on exiting due to a Unity's logging interface being used after released.
* Changed the XR validator rule based on the Unity versions with related bug fixes so that the HL2 apps can run properly without the "Run in Background" project settings.
* Fixed a bug where app remoting doesn't work when the user doesn't have permission to create regkey in HKCU.
* Fixed a bug where`AppRemoting.ReadyToStart` event is invoked incorrectly before `AppRemoting.StopListening` is used.
* Fixed a bug where some AppRemoting API methods were incorrectly enabled that should have been disabled
* When the app is used in Unity Editor with `Holographic Remoting for PlayMode` feature enabled in Unity Project Settings, AppRemoting API methods should be disabled.
* Fixed a bug where haptic binding is not available for HP Reverb G2.
## [1.7.2] - 2023-03-03
* Fixed a bug where using some APIs from non-main threads could cause errors and incorrect behavior.
## [1.7.1] - 2023-03-02
* Version 1.7.1 was packaged incorrectly and should be avoided.
* Version 1.7.2 is a replacement for 1.7.1.
## [1.7.0] - 2022-12-15
* Fixed compatibility with the 1.6.0 release of Unity's OpenXR plugin.
* Fixed bugs where Unity application crashes due to unhandled exceptions in MR plugin.
* Fixed a bug that the Unity MR plugin was not properly cleaned up due to unbalanced module ref count.
* Added new API `AppRemoting.StartConnectingToPlayer` for connect mode app remoting. It replaces the deprecated `AppRemoting.Connect'.
* Added new API `AppRemoting.StartListeningForPlayer` for listen mode app remoting. It replaces the deprecated `AppRemoting.Listen'.
* Added new API `AppRemoting.StopListening` to stop listening on the remote app for incoming connections.
* Added new API `AppRemoting.IsReadyToStart` to indicate when app remoting is ready to be started.
* Added new APIs for secure mode app remoting connections, e.g. `AppRemoting.SecureRemotingConnectConfiguration` and `AppRemoting.SecureRemotingListenConfiguration`
* Added new events `AppRemoting.Connected`, `AppRemoting.Disconnecting`, and `AppRemoting.ReadyToStart` in addition to existing `AppRemoting.TryGetConnectionState` function.
## [1.6.0] - 2022-11-02
* Depends on version 1.5.3 of Unity's OpenXR plugin.
* Fixed a bug where Holographic Remoting remote app may fail connection to remoting player
* Update the remoting OpenXR runtime to 2.8.1 release.
* Added support for XR_MSFT_spatial_anchor_export extension in remoting OpenXR runtime.
* Added better support for `SpatialGraphNode.FromStaticNodeId` in remoting OpenXR runtime.
* Added new dependency to com.unity.xr.core-utils package
* Changed project settings recommendation for HoloLens 2 to use [Unity's project validation system](https://docs.unity3d.com/Packages/com.unity.xr.core-utils@2.1/manual/project-validation.html)
* Added new API `AnchorConverter.CreateFromOpenXRHandle` for creating ARAnchor from OpenXR handle.
* Added new API `ViewConfiguration.StereoSeparationAdjustment` for adjusting the stereo separation on HoloLens 2.
* Supports running Holographic Remoting remote app in elevated process.
* Fixed a bug where remoting app build may fail if building into a non-standard exe name or building a Standalone build with "Create Visual Studio Solution" enabled.
* Fixed a bug in validator which incorrectly recommend disabling "Run in Background" settings. Enabling this setting can workaround a Unity bug so that Unity app can continue rendering when the app lost keyboard focus.
* Fixed a bug where the Mixed Reality OpenXR Plugin DLL wasn't being included in the build when specific features (Hand Tracking and Mixed Reality Features) weren't checked.
## [1.5.1] - 2022-09-15
* Fixed a bug where apps may be deadlocked and stop rendering due to a race condition when using ARMeshManager to acquire meshes.
## [1.5.0] - 2022-08-31
* Added new API `AppRemoting.TryLocateUserReferenceSpace` to locate the [XR_REMOTING_REFERENCE_SPACE_TYPE_USER_MSFT reference space](https://docs.microsoft.com/windows/mixed-reality/develop/native/holographic-remoting-coordinate-system-synchronization-openxr) in Unity's scene origin space in the remote app.
* The [ControllerModel](https://docs.microsoft.com/dotnet/api/microsoft.mixedreality.openxr.controllermodel) API now also supports loading Quest controller models.
* Fixed a bug where MeshProvider.AcquireMesh might crash in a rare race condition.
* Added warning message for the user to know that app remoting failure was due to the app running in elevated mode.
* Added new [`HandTracker.MotionRange`](https://docs.microsoft.com/dotnet/api/microsoft.mixedreality.openxr.handtracker.motionrange) API to support [hand joints motion range](https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_joints_motion_range).
* Fixed a bug where some new anchors were not tracked before their first update.
* Added a validator to remove "Run In Background" project setting for HoloLens 2 apps.
* Added a [SelectKeywordRecognizer](https://docs.microsoft.com/dotnet/api/microsoft.mixedreality.openxr.selectkeywordrecognizer) to allow developers to get notification when the "select" keyword is said on HoloLens 2.
* Added a new property [`ControllerModel.IsSupported`](https://docs.microsoft.com/dotnet/api/microsoft.mixedreality.openxr.controllermodel.issupported) to ControllerModel class.
* Renamed the API `AnchorProvider.FromPerceptionSpatialAnchor` to `AnchorProvider.CreateFromPerceptionSpatialAnchor` and the old method is now deprecated.
* Added support to [`CommonUsages.trackingState`](https://docs.unity3d.com/ScriptReference/XR.CommonUsages-trackingState.html) for hand tracking input device.
* Added support for Unity's [KeywordRecognizer](https://docs.unity3d.com/ScriptReference/Windows.Speech.KeywordRecognizer.html) over Holographic Remoting for Play Mode.
* Added new [`ControllerModelArticulator`](https://docs.microsoft.com/dotnet/api/microsoft.mixedreality.openxr.controllermodelarticulator) API for rendering controller model parts articulation.
* Fixed a potential null reference exception when calling the app remoting APIs on unsupported platforms.
* Removed dependency on Unity.Subsystem.Registration assembly.
## [1.4.4] - 2022-08-08
* Fixed a bug caused by some runtimes reporting an active hand tracker while returning invalid hand joint poses.
* Fixed a bug caused by some runtimes reporting an active hand tracker while returning invalid hand joint poses.
## [1.4.3] - 2022-07-21
* Newly added ARAnchors will now report at least one update through the ARAnchorManager anchorsChanged event.
## [1.4.2] - 2022-07-06
* Fixed a bug where the anchors are located incorrectly after user clear all holograms in user's settings page.
* Fixed a bug where rendering framerate might be dropped due to hand and controller tracking cost.
* Fixed a bug where ARPlanes might be incorrectly reported as updated or removed before they are reported as added.
* Added feature validation to warn developer about missing internet capabilities in appxmanifest for remoting apps.
## [1.4.1] - 2022-06-07
* Depends on version 1.4.2 of Unity's OpenXR plugin.
* Fixed unnecessary destroying session on pause and resume.
* Fixed a bug where ARAnchor doesn't relocate properly after suspend and resume on HL2.
* Fixed an editor crash issue when updating OpenXR package version and then enter Playmode.
* Fixed a bug where AR Subsystems would clear trackables on subsystem stop/restart. Trackables will now only be cleared in this way on subsystem destroy/recreate.
* Fixed a bug where meshes provided through the XRMeshSubsystem could have the wrong 'updated' value.
* Fixed a bug where occlusion-optimized meshes were being computed at the wrong cadence.
* Fixed a bug where the app or Unity editor could crash when an OpenXR extension was not available.
* Fixed a bug where the XRAnchorSubsystem would not report anchors as removed when a remoting session was ended.
* Fixed a bug where the XRAnchorStore could not be loaded after a remoting session had disconnected and reconnected.
* Fixed a bug where loading an anchor from the XRAnchorStore multiple times would result in multiple ARAnchors.
* Upgraded the OpenXR remoting runtime to 2.8.0 release.
## [1.4.0] - 2022-04-05
* Added SpatialGraphNode.FromDynamicNodeId() function to support interop with PV camera tracking.
* Added SpatialGraphNode.TryLocate(long qpcTime) function to support locating space at a historical time.
* Deprecated the "IDisposable" usage of GestureRecognizer, and replaced with "Destroy" function.
* Deprecated the MeshComputeSettings.MeshType property.
* Deprecated the XRAnchorStore.LoadAsync in favor of extension methods LoadAnchorStoreAsync.
* Fixed the ViewConfigurationType enum values to match OpenXR standard.
* Added a setting for application to choose MRC rendering between extra render pass with better hologram alignment using first person observer, or less render pass with better performance but compromise on hologram alignment.
* Support PlayMode remoting when the Unity project turned off "initialize XR at start up" setting, typically for Holographic remoting app.
* Note: ARFoundation trackable managers will not connect to XR subsystems if the trackable managers are active in the Unity scene before XR initialization. The application must disable then reenable these trackable managers after XR initialization, or wait to add active trackable managers to the scene until after XR initialization.
* Improved the performance by reducing the update events of ARAnchor and ARPlane when there's no location updates from the runtime.
* Upgraded the OpenXR remoting runtime to 2.7.5 release
## [1.3.1] - 2022-02-16
* Fixed a bug where Unity editor sometimes crashes after upgrading the MR OpenXR plugin package.
## [1.3.0] - 2022-02-09
* Fixed a bug where input system sometimes reports identity rotation for controller pose when the Hand Tracking feature was enabled.
* Enabled the "Hand Tracking feature" when it's used together with Unity's Oculus Quest feature.
* Fixed a crash on app resume when using plane finding.
## [1.2.1] - 2021-12-03
* Depends on version 1.3.1 of Unity's OpenXR plugin.
* Fixed a bug where UWP remoting app won't render desktop view after XR session is started.
* Fixed a bug where a restart of XR session prevent future restart to happen.
* Fixed incorrect negative values on controller linear velocities.
* Fixed a bug that prevent UWP app to resume after suspend to background.
## [1.2.0] - 2021-11-18
* Depends on version 1.3.0 of Unity's OpenXR plugin.
* Supports better HoloLens hand interaction action binding
* Fixed a crash during app suspend/resume when taking MRC video
* Depends on version 4.2.0 of XR management package.
* Fixed a bug where sometimes the the project settings assets are not created before being used.
* Added Microsoft.MixedReality.OpenXR.Remoting.AppRemoting.Listen function to support listen mode for a Holographic Remoting remote app.
* Added new enum value HandshakePermissionDenied to enum type RemotingDisconnectReason.
* Fixed a bug where after a failed remoting connection the XR session automatically restarted and repeat the failure.
* When hand tracking becomes untracked or out of view, the corresponding InputDevice for hand joints will remain valid and report `isTracked = false`, instead of invalidating the InputDevice.
## [1.1.2] - 2021-10-27
* Fixed a bug where Unity Editor sometimes cannot quit after an unsuccessful connection to Holographic Remoting player in Play Mode.
* Update the OpenXR remoting runtime to 2.7.1 release.
## [1.1.1] - 2021-10-15
* Fixed a bug where projects would fail to build if the project also referenced DotNetWinRT package.
## [1.1.0] - 2021-10-07
* Added new APIs for spatial anchor transfer batch: Microsoft.MixedReality.OpenXR.XRAnchorTransferBatch
* Supports the XRMeshSubsystem through OpenXR scene understanding extensions.
* Supports OpenXR remoting runtime 2.7, with Spatial Anchor Store and Surface mapping in Holographic Remoting apps.
* Removed direct package dependency to ARSubsystem package. It's now implicit through ARFoundation package.
* Fixed a bug where Unity's UI froze briefly when Holographic Remoting failed to connect to remote player app.
* Fixed a bug where persisted anchor may lead to error saying "An item with the same key has already been added."
* Supports the ratified "XR_MSFT_scene_understanding" extension instead of "_preview3" version.
* Fixed a bug where projects would fail to build with Windows XR Plugin installed and app remoting enabled.
## [1.0.3] - 2021-09-07
* Supports the OpenXR spatial anchor persistence MSFT extension.
* Fixed a bug where Editor Remoting settings are present in PackageSettings instead of UserSettings.
* Fixed a bug where some anchors could fail to be persisted after clearing the XRAnchorStore.
* Fixed a bug where extra anchors were created when switching between Unity scenes.
## [1.0.2] - 2021-08-05
* Depends on Unity's 1.2.8 OpenXR plugin.
* Fixed a bug where ARAnchors were occasionally not removed properly.
* Fixed a bug where invalid ARAnchor changes were occasionally reported after restarting Holographic Remoting for Play Mode.
* Fixed a bug where view configurations were not properly reported when using Holographic Remoting for Play Mode.
* Added more specific settings validation with more precise messages when using Holographic Remoting for Play Mode.
* Added validation for "Initialize XR on Startup" setting when using Holographic Remoting for Play Mode.
## [1.0.1] - 2021-07-13
* Depends on Unity's 1.2.3 OpenXR plugin.
* Updated Holographic Remoting runtime to 2.6.0
* Removed the "Holographic Remoting for Play Mode" feature group from Unity settings UX and kept the feature independent.
* Fixed a bug where build process cannot find the app.cpp when building a XAML type unity project.
## [1.0.0] - 2021-06-18
* Fixed a bug where a the XRAnchorSubsystem was always started on app start regardless ARAnchorManager's present.
* Fixed a bug where the reprojection mode didn't work properly.
## [1.0.0-preview.2] - 2021-06-14
* Depends on Unity's 1.2.2 OpenXR plugin.
* Changed Holographic Remoting features in to individual feature groups.
* Fixed a bug where "Apply HoloLens 2 project settings" changes project color space. This is no longer needed after Unity OpenXR 1.2.0 plugin.
* Fixed a bug where a input device get connected without disconnect after application suspended and resumed.
* Added support for detecting plugin and current tracking states via ARSession.
* Fixed a bug where the "AR Default Plane" ARFoundation prefab wouldn't be visible.
## [1.0.0-preview.1] - 2021-06-02
* Supports OpenXR scene understanding MSFT extensions instead of preview extensions.
* Plane detection on HoloLens 2 no longer requires preview versions of the Mixed Reality OpenXR runtimes.
## [0.9.5] - 2021-05-21
* Depends on Unity's 1.2.0 OpenXR Plugin
* Adapted to the new feature UI (in OpenXR Plugin 1.2.0) for configuration.
* Fixed a bug where the locatable camera provider wasn't properly unregistering.
* Cleaned up some extra usages of `[Preserve]`.
* Update "HP Reverb G2 Controller (OpenXR)" name in the input system UI.
## [0.9.4] - 2021-05-20
* Depends on Unity's 1.2.0 OpenXR Plugin.
* Added new C# API to get motion controller glTF model.
* Added new C# API to get enabled view configurations and set reprojection settings.
* Added new C# API to set additional settings for computing meshes with XRMeshSubsystem.
* Added new C# API to configure and subscribe to gesture recognition events.
* Added Windows->XR->Editor Remoting settings dialog.
* Added ARM support for HoloLens UWP applications.
## [0.9.3] - 2021-04-29
* Fixed a bug where Holographic remoting connection is not reliable
* Fixed a bug where the VR rendering performance is sub-optimum after upgrade to Unity's 1.1.1 OpenXR plugin.
## [0.9.2] - 2021-04-21
* Plane detection on HoloLens 2 in plugin version 0.9.1 will work with version 105 of the Mixed Reality OpenXR preview runtime.
* Plane detection on HoloLens 2 in plugin version 0.9.2 will work with version 106 of the Mixed Reality OpenXR preview runtime.
* Removed some unused callbacks from InputProvider to prevent calls like XRInputSubsystem.GetTrackingOriginMode (which aren't managed by our input system) from returning success with misleading values.
* Split out deprecated version of XRAnchorStore into its own file to prevent Unity console warning.
## [0.9.1] - 2021-04-20
* Depends on Unity's 1.1.1 OpenXR Plugin.
* Added support for [Holographic Remoting application](https://aka.ms/openxr-unity-app-remoting) for UWP platform.
* Fix UnityException where XRAnchorStore was trying to get a settings instance outside the main thread.
## [0.9.0] - 2021-03-29
* Added support for spatial mapping via XRMeshSubsystem and ARMeshManager.
* Added new C# API to get OpenXR handles to support other Unity packages consumes OpenXR extensions.
* Added new C# API to interop with Windows.Perception APIs to support other Unity packages consuming Perception WinRT APIs.
* Removed interaction profiles from required features in Windows Mixed Reality feature set, so developers can choose the motion controllers they tested with.
* Added Holographic editor remoting feature validator to help users to setup editor remoting properly.
* Fixed a bug where Unity editor crashes when exiting Holographic editor remoting mode after connection failure.
* Fixed a bug where unpremultipled alpha textures leads to sub-optimum performance on HoloLens 2.
* Fixed a bug where hand tracking was not located correctly when the scene origin was at floor level.
* Fixed a bug where hand mesh tracking disappear after leaving and loading a new scene.
* Fixed a bug where locatable camera provider didn't properly clean up.
* Revised the namespace of XRAnchorStore API into Microsoft.MixedReality.OpenXR.
## [0.2.0] - 2021-03-24
* Depends on Unity's 1.0.3 OpenXR Plugin.
* Removed deprecated preview APIs.
* Supports new API "EyeLevelSceneOrigin" for easily setup eye level experience for HoloLens 2.
* Supports plane detection using the ARPlaneSubsystem on HoloLens 2.
* Supports single raycasts for planes using the ARRaycastSubsystem on HoloLens 2.
* Supports new HandMeshTracker API for hand mesh tracking inputs on HoloLens 2.
* Fixed a bug where ARAnchor is not properly reporting tracking state.
## [0.1.5] - 2021-03-15
* Fixed a bug where using an HP Reverb G2 controller lead to errors in the Unity plugin.
* Fixed a bug that the Unity's "Input Debugger" window is blank when using Mixed Reality plugin.
## [0.1.4] - 2021-03-02
* Depends on Unity's 1.0.2 OpenXR Plugin.
* Fixed a bug where SpatialGraphNode's TryLocateSpace's FrameTime parameter was ignored.
* Fixed a bug where hand tracking could occasionally cause a crash.
## [0.1.3] - 2021-02-11
* Adds support for [desktop app holographic remoting](https://aka.ms/openxr-unity-app-remoting).
* Adds support for "SpatialGraphNode" API that bridges to other Mixed Reality tracking libraries, such as QR code tracking.
* Promote "FrameTime" concept from Preview API to supported API.
* Fixed a bug where eye tracking device capability is duplicated in manifest file.
* Fixed a bug where the plugin doesn't compile in Unity 2021.1+.
## [0.1.2] - 2021-01-08
* Depends on Unity's 0.1.2-preview.2
* Fixed unnecessary error message in XRAnchorStore before XR plugin is initialized.
* Fixed a bug where HandTracker's `TryLocateHandJoints` method might throw a `DllNotFoundException` if the DLL wasn't properly loaded. It now returns `false` instead.
## [0.1.1] - 2020-12-18
* Fixed a bug where non-existent sources were being reported disconnected on shutdown, possibly causing errors.
* Fixed a bug that the menu button on HP Reverb G2 didn't bind correctly.
* Changed the SetSceneOrigin script to focus on overriding eye level experience instead.
* Fixed a bug that returns incorrect room boundary on Mixed Reality headset.
* Fixed a bug where sample scene anchor scenarios didn't work with ARFoundation before 4.1.1.
## [0.1.0] - 2020-12-16
### Initial release
This is initial release of *Mixed Reality OpenXR Plugin \<com.microsoft.mixedreality.openxr\>*.
* Supports both UWP applications for HoloLens 2 and Win32 VR applications for Windows Mixed Reality headsets.
* Optimizes UWP package and CoreWindow interaction for HoloLens 2 applications.
* Supports motion controller and hand interactions, including the new HP Reverb G2 controller.
* Supports articulated hand tracking using 26 joints and joint radius inputs.
* Supports eye gaze interaction on HoloLens 2.
* Supports locating PV camera on HoloLens 2.
* Supports mixed reality capture using 3rd eye rendering through PV camera.
* Supports "Play" to HoloLens 2 using Holographic Remoting app, allow developers to debug scripts without build and deploy to the device.
* Compatible with MRTK Unity 2.5.2 through MRTK OpenXR adapter package.

7
com.microsoft.mixedreality.openxr/CHANGELOG.md.meta Normal file
View File

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

13
com.microsoft.mixedreality.openxr/Documentation~/README.md Normal file
View File

@ -0,0 +1,13 @@
# Mixed Reality OpenXR Plugin for Unity
This "Mixed Reality OpenXR Plugin" package is an extension to Unity's "OpenXR Plugin"
to support a suite of features for HoloLens 2 and Windows Mixed Reality headsets
This package requires Unity 2021.3+ and the "OpenXR Plugin" package from Unity.
Please reference [online documents](https://aka.ms/openxr-unity) to learn more details
about setting up a Unity project and using this plugin to build Unity applications
for HoloLens 2 and Windows Mixed Reality headsets.
Please reference [OpenXR-Unity-MixedReality-Samples](https://github.com/microsoft/OpenXR-Unity-MixedReality-Samples)
to find sample projects using this package to build Unity applications on HoloLens 2.

8
com.microsoft.mixedreality.openxr/Editor.meta Normal file
View File

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

9
com.microsoft.mixedreality.openxr/Editor/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,9 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft.MixedReality.OpenXR.Internal.Editor")]
[assembly: AssemblyVersion("1.11.1")]

11
com.microsoft.mixedreality.openxr/Editor/AssemblyInfo.cs.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Editor/BuildProcessors.meta Normal file
View File

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

150
com.microsoft.mixedreality.openxr/Editor/BuildProcessors/MetaBuildProcessor.cs Normal file
View File

@ -0,0 +1,150 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Xml;
using UnityEditor.Build.Reporting;
using UnityEditor.XR.OpenXR.Features;
using static Microsoft.MixedReality.OpenXR.Editor.BuildProcessorHelpers;
using static Microsoft.MixedReality.OpenXR.Editor.BuildProcessorHelpers.AndroidManifest;
namespace Microsoft.MixedReality.OpenXR.Editor
{
internal class MetaBuildProcessor : OpenXRFeatureBuildHooks
{
public override int callbackOrder => 1;
public override Type featureType =>
#if UNITY_OPENXR_1_6_OR_NEWER
typeof(UnityEngine.XR.OpenXR.Features.MetaQuestSupport.MetaQuestFeature);
#else
typeof(UnityEngine.XR.OpenXR.Features.OculusQuestSupport.OculusQuestFeature);
#endif
protected override void OnPreprocessBuildExt(BuildReport report) { }
protected override void OnPostGenerateGradleAndroidProjectExt(string path)
{
HandTrackingFeaturePlugin handTrackingFeaturePlugin = GetOpenXRFeature<HandTrackingFeaturePlugin>();
bool handTrackingEnabled = handTrackingFeaturePlugin != null && handTrackingFeaturePlugin.enabled;
bool motionControllerModelEnabled = IsFeatureEnabled<MotionControllerFeaturePlugin>();
if (!handTrackingEnabled && !motionControllerModelEnabled)
{
return;
}
AndroidManifest androidManifest = new AndroidManifest(GetManifestPath(path));
if (handTrackingEnabled)
{
androidManifest.EnsurePermission("com.oculus.permission.HAND_TRACKING");
androidManifest.EnsureFeature("oculus.software.handtracking", false);
if (handTrackingFeaturePlugin.QuestHandTrackingMode == HandTrackingFeaturePlugin.QuestHandTracking.v2)
{
androidManifest.EnsureMetaData("com.oculus.handtracking.version", "V2.0");
}
else if (handTrackingFeaturePlugin.QuestHandTrackingMode == HandTrackingFeaturePlugin.QuestHandTracking.v1)
{
androidManifest.EnsureMetaData("com.oculus.handtracking.version", "V1.0");
}
}
if (motionControllerModelEnabled)
{
androidManifest.EnsurePermission("com.oculus.permission.RENDER_MODEL");
androidManifest.EnsureFeature("com.oculus.feature.RENDER_MODEL");
}
androidManifest.Save();
}
protected override void OnPostprocessBuildExt(BuildReport report) { }
}
internal static class AndroidManifestExtensions
{
internal static void EnsurePermission(this AndroidManifest manifest, string permissionString)
{
XmlNode usesPermission = null;
foreach (XmlNode child in manifest.RootElement.ChildNodes)
{
if (child.Name == "uses-permission" &&
HasAttribute(child, "android:name", permissionString))
{
usesPermission = child;
if (usesPermission != null)
{
break;
}
}
}
if (usesPermission == null)
{
usesPermission = manifest.RootElement.AppendChild(manifest.CreateElement("uses-permission"));
usesPermission.Attributes.Append(manifest.CreateAndroidAttribute("name", permissionString));
}
}
internal static void EnsureFeature(this AndroidManifest manifest, string featureString, bool? required = null)
{
XmlNode usesFeature = null;
foreach (XmlNode child in manifest.RootElement.ChildNodes)
{
if (child.Name == "uses-feature" &&
HasAttribute(child, "android:name", featureString))
{
usesFeature = child;
if (usesFeature != null)
{
break;
}
}
}
if (usesFeature == null)
{
usesFeature = manifest.RootElement.AppendChild(manifest.CreateElement("uses-feature"));
usesFeature.Attributes.Append(manifest.CreateAndroidAttribute("name", featureString));
}
if (required.HasValue && !SetAttribute(usesFeature, "android:required", required.Value.ToString()))
{
usesFeature.Attributes.Append(manifest.CreateAndroidAttribute("required", required.Value.ToString()));
}
}
internal static void EnsureMetaData(this AndroidManifest manifest, string nameString, string valueString)
{
XmlNode metaData = null;
foreach (XmlNode child in manifest.ApplicationElement.ChildNodes)
{
if (child.Name == "meta-data" &&
HasAttribute(child, "android:name", nameString))
{
metaData = child;
if (metaData != null)
{
break;
}
}
}
if (metaData == null)
{
metaData = manifest.ApplicationElement.AppendChild(manifest.CreateElement("meta-data"));
metaData.Attributes.Append(manifest.CreateAndroidAttribute("name", nameString));
}
if (!SetAttribute(metaData, "android:value", valueString))
{
metaData.Attributes.Append(manifest.CreateAndroidAttribute("value", valueString));
}
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/BuildProcessors/MetaBuildProcessor.cs.meta Normal file
View File

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

399
com.microsoft.mixedreality.openxr/Editor/BuildProcessors/MixedRealityBuildProcessor.cs Normal file
View File

@ -0,0 +1,399 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if UNITY_EDITOR
using Microsoft.MixedReality.OpenXR.Remoting;
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Xml.Linq;
using UnityEditor;
using UnityEditor.Build.Reporting;
using UnityEditor.XR.OpenXR.Features;
using UnityEngine;
using UnityEngine.XR.OpenXR.Features;
namespace Microsoft.MixedReality.OpenXR.Editor
{
// Customize code for UWP (aka WSA platform)
// Enable the "holographic window attachment" and slightly modify the app.cpp file in app.
internal class MixedRealityBuildProcessor : OpenXRFeatureBuildHooks
{
private const string MixedRealityPluginName = "MicrosoftOpenXRPlugin.dll";
private const string PerceptionDeviceName = "PerceptionDevice.dll";
private const string RemotingRuntimeName = "Microsoft.Holographic.AppRemoting.OpenXr.dll";
private const string RemotingSceneUnderstandingName = "Microsoft.Holographic.AppRemoting.OpenXr.SU.dll";
private const string RemotingJsonName = "RemotingXR.json";
private const string RemotingJsonGuid = "db1217138e9d063459fa78b3e75f4f93";
private const string OpenXR = "com.microsoft.mixedreality.openxr";
private const string SamplesRepoURL = "https://github.com/microsoft/OpenXR-Unity-MixedReality-Samples";
private static readonly Dictionary<string, string> BootVars = new Dictionary<string, string>()
{
{"force-primary-window-holographic", "1"},
{"vr-enabled", "1"},
{"xrsdk-windowsmr-library", NativeLib.DllName + ".dll"},
{"early-boot-windows-holographic", "1"},
};
public override void OnPreprocessBuild(BuildReport report)
{
base.OnPreprocessBuild(report);
PluginImporter[] allPlugins = PluginImporter.GetAllImporters();
foreach (PluginImporter plugin in allPlugins)
{
if (plugin.isNativePlugin && plugin.assetPath.Contains(OpenXR))
{
if (plugin.assetPath.Contains(MixedRealityPluginName))
{
plugin.SetIncludeInBuildDelegate(IsMixedRealityNativePluginRequired);
}
else if (plugin.assetPath.Contains(RemotingRuntimeName))
{
plugin.SetIncludeInBuildDelegate(IsRemotingRuntimeRequired);
}
else if (plugin.assetPath.Contains(RemotingSceneUnderstandingName))
{
plugin.SetIncludeInBuildDelegate(IsRemotingRuntimeRequired);
}
else if (plugin.assetPath.Contains(PerceptionDeviceName))
{
plugin.SetIncludeInBuildDelegate(IsRemotingRuntimeRequired);
}
}
}
}
protected override void OnPreprocessBuildExt(BuildReport report)
{
if (report.summary.platformGroup == BuildTargetGroup.WSA)
{
PreprocessBuildForWSA(report);
}
}
private void PreprocessBuildForWSA(BuildReport report)
{
// Write boot settings before build
BootConfig bootConfig = new BootConfig(report);
bootConfig.ReadBootConfig();
foreach (KeyValuePair<string, string> entry in BootVars)
{
if (entry.Key == "force-primary-window-holographic" && IsRemotingRuntimeRequired())
{
// When AppRemoting is enabled, skip the flag to force primary corewindow to be holographic (it won't be).
// If this flag exist, Unity might hit a bug that it skips rendering into the CoreWindow on the desktop.
continue;
}
bootConfig.SetValueForKey(entry.Key, entry.Value);
}
bootConfig.WriteBootConfig();
}
protected override void OnPostprocessBuildExt(BuildReport report)
{
if (report.summary.platformGroup == BuildTargetGroup.WSA)
{
PostprocessBuildForWSA(report);
}
CheckRemotingJson(report, IsRemotingRuntimeRequired());
}
private void PostprocessBuildForWSA(BuildReport report)
{
// Clean up boot settings after build
BootConfig bootConfig = new BootConfig(report);
bootConfig.ReadBootConfig();
foreach (KeyValuePair<string, string> entry in BootVars)
{
bootConfig.ClearEntryForKeyAndValue(entry.Key, entry.Value);
}
bootConfig.WriteBootConfig();
if (IsRemotingRuntimeRequired())
{
AddRemotingJsonToData(Path.Combine(report.summary.outputPath, PlayerSettings.productName));
VerifyPackageManifestCapabilities(Path.Combine(report.summary.outputPath, PlayerSettings.productName));
}
RemoveSuppressSystemOverlays(report);
}
/// <summary>
/// Copies RemotingXR.json to or deletes from the build folder, depending on shouldExist.
/// </summary>
/// <param name="report">The build report from Unity's build hooks events.</param>
/// <param name="shouldExist">If the file should be present in the build.</param>
private void CheckRemotingJson(BuildReport report, bool shouldExist)
{
string path = report.summary.outputPath;
if (report.summary.platform == BuildTarget.WSAPlayer)
{
path = Path.Combine(path, PlayerSettings.productName, RemotingJsonName);
}
else if (report.summary.platform == BuildTarget.StandaloneWindows64)
{
string folderName = Path.GetFileNameWithoutExtension(report.summary.outputPath);
// When building with "Create Visual Studio Solution", this API still reports a .exe
// in the output path (but it doesn't exist, so we can assume we're building a .sln)
if (path.EndsWith(".exe") && !File.Exists(path))
{
path = Path.Combine(path, "..", "build", "bin");
}
else
{
path = Path.Combine(path, "..");
}
path = Path.Combine(path, folderName + "_Data", "Plugins", "x86_64", RemotingJsonName);
}
else
{
// Other platforms aren't supported
return;
}
string folderPath = Directory.GetParent(path).FullName;
if (!Directory.Exists(folderPath))
{
Debug.LogError($"The {nameof(MixedRealityBuildProcessor)} could not find the Plugins folder (looked in {folderPath}).\n" +
$"Please file an issue on {SamplesRepoURL}, as this is unexpected. Holographic Remoting may not work as a result.");
}
else if (shouldExist)
{
File.Copy(Path.GetFullPath(AssetDatabase.GUIDToAssetPath(RemotingJsonGuid)), path, true);
}
else if (File.Exists(path))
{
File.Delete(path);
}
}
/// <summary>
/// Adds a line in the Unity data file project to include the remoting file in the build.
/// </summary>
/// <param name="path">The path to the folder that contains Unity Data.vcxitems.</param>
private void AddRemotingJsonToData(string path)
{
const string UnityDataPath = "Unity Data.vcxitems";
path = Path.Combine(path, UnityDataPath);
XElement root = XElement.Load(path);
foreach (XElement itemGroup in root.Elements(root.GetDefaultNamespace() + "ItemGroup"))
{
foreach (XElement remotingDll in itemGroup.Elements(root.GetDefaultNamespace() + "None"))
{
XAttribute includeDll = remotingDll.Attribute("Include");
if (includeDll != null && includeDll.Value.Contains(RemotingRuntimeName))
{
XElement jsonElement = new XElement(remotingDll);
// Update "Include" to point to the json, but leave "Condition" alone so it's still dependent on the remoting binary existing
jsonElement.Attribute("Include").Value = jsonElement.Attribute("Include").Value.Replace(RemotingRuntimeName, RemotingJsonName);
itemGroup.Add(jsonElement);
root.Save(path);
return;
}
}
}
}
/// <summary>
/// Verifies if the internet capabilities in Package.appxmanifest match the ones in the Unity Player Settings for Holographic App remoting to work properly.
/// </summary>
/// <param name="path">The path to the folder that contains Package.appxmanifest.</param>
private void VerifyPackageManifestCapabilities(string path)
{
bool internetClientEnabled = false, internetClientServerEnabled = false, privateNetworkClientServerEnabled = false, microphone = false;
const string PackageManifestPath = "Package.appxmanifest";
path = Path.Combine(path, PackageManifestPath);
XmlDocument manifest = new XmlDocument();
manifest.Load(path);
XmlNode root = manifest.DocumentElement;
// Get the internet capabilities that are enabled from manifest
foreach (XmlNode childNode in root.ChildNodes)
{
if (childNode.Name == "Capabilities")
{
foreach (XmlNode capability in childNode.ChildNodes)
{
if (capability.Name == "Capability")
{
foreach (XmlAttribute attribute in capability.Attributes)
{
if (attribute.Name == "Name" && attribute.Value == "internetClient")
{
internetClientEnabled = true;
}
if (attribute.Name == "Name" && attribute.Value == "internetClientServer")
{
internetClientServerEnabled = true;
}
if (attribute.Name == "Name" && attribute.Value == "privateNetworkClientServer")
{
privateNetworkClientServerEnabled = true;
}
if (attribute.Name == "Name" && attribute.Value == "microphone")
{
microphone = true;
}
}
}
}
}
}
// Generate a warning, if the capabilities in the manifest don't match the ones in Unity Player Settings
if (PlayerSettings.WSA.GetCapability(PlayerSettings.WSACapability.InternetClient) != internetClientEnabled)
{
Debug.LogWarning("The InternetClient capability in the existing Package.appxmanifest does not match the capability in this project's Player settings." +
" To update the existing Package.appxmanifest to reflect your project's current Player settings, please edit the file manually" +
" or regenerate the Package.appxmanifest.");
}
if (PlayerSettings.WSA.GetCapability(PlayerSettings.WSACapability.InternetClientServer) != internetClientServerEnabled)
{
Debug.LogWarning("The InternetClientServer capability in the existing Package.appxmanifest does not match the capability in this project's Player settings." +
" To update the existing Package.appxmanifest to reflect your project's current Player settings, please edit the file manually" +
" or regenerate the Package.appxmanifest.");
}
if (PlayerSettings.WSA.GetCapability(PlayerSettings.WSACapability.PrivateNetworkClientServer) != privateNetworkClientServerEnabled)
{
Debug.LogWarning("The PrivateNetworkClientServer capability in the existing Package.appxmanifest does not match the capability in this project's Player settings." +
" To update the existing Package.appxmanifest to reflect your project's current Player settings, please edit the file manually" +
" or regenerate the Package.appxmanifest.");
}
if (PlayerSettings.WSA.GetCapability(PlayerSettings.WSACapability.Microphone) != microphone)
{
Debug.LogWarning("The Microphone capability in the existing Package.appxmanifest does not match the capability in this project's Player settings." +
" To update the existing Package.appxmanifest to reflect your project's current Player settings, please edit the file manually" +
" or regenerate the Package.appxmanifest.");
}
}
// Remove the deprecated usage of SuppressSystemOverlays from Unity UWP project template.
private void RemoveSuppressSystemOverlays(BuildReport report)
{
string appCppPath = Path.Combine(report.summary.outputPath, PlayerSettings.productName, "App.cpp");
// For certain types of builds, like XAML builds, App.cpp won't exist. App.xaml.cpp does though.
if (!File.Exists(appCppPath))
{
appCppPath = Path.Combine(report.summary.outputPath, PlayerSettings.productName, "App.xaml.cpp");
}
string appCppLines = File.ReadAllText(appCppPath);
const string Pattern = @"\r?\n.*SuppressSystemOverlays.*\r?\n";
string modifiedAppCppLines = System.Text.RegularExpressions.Regex.Replace(appCppLines, Pattern, "");
File.WriteAllText(appCppPath, modifiedAppCppLines);
}
private static bool IsRemotingRuntimeRequired(string path = "") => BuildProcessorHelpers.IsFeatureEnabled<AppRemotingPlugin>();
private static bool IsMixedRealityNativePluginRequired(string path = "")
{
if (IsRemotingRuntimeRequired(path))
{
return true;
}
foreach (OpenXRFeature feature in BuildProcessorHelpers.GetOpenXRFeatures())
{
if (feature.IsValidAndEnabled() && Attribute.IsDefined(feature.GetType(), typeof(RequiresNativePluginDLLsAttribute)))
{
return true;
}
}
return false;
}
/// <summary>
/// Small utility class for reading, updating and writing boot config.
/// </summary>
private class BootConfig
{
private const string XrBootSettingsKey = "xr-boot-settings";
private readonly Dictionary<string, string> bootConfigSettings;
private readonly string buildTargetName;
public BootConfig(BuildReport report)
{
bootConfigSettings = new Dictionary<string, string>();
buildTargetName = BuildPipeline.GetBuildTargetName(report.summary.platform);
}
public void ReadBootConfig()
{
bootConfigSettings.Clear();
string xrBootSettings = EditorUserBuildSettings.GetPlatformSettings(buildTargetName, XrBootSettingsKey);
if (!string.IsNullOrEmpty(xrBootSettings))
{
// boot settings string format
// <boot setting>:<value>[;<boot setting>:<value>]*
var bootSettings = xrBootSettings.Split(';');
foreach (var bootSetting in bootSettings)
{
var setting = bootSetting.Split(':');
if (setting.Length == 2 && !string.IsNullOrEmpty(setting[0]) && !string.IsNullOrEmpty(setting[1]))
{
bootConfigSettings.Add(setting[0], setting[1]);
}
}
}
}
public void SetValueForKey(string key, string value) => bootConfigSettings[key] = value;
public void ClearEntryForKeyAndValue(string key, string value)
{
if (bootConfigSettings.TryGetValue(key, out string dictValue) && dictValue == value)
{
bootConfigSettings.Remove(key);
}
}
public void WriteBootConfig()
{
// boot settings string format
// <boot setting>:<value>[;<boot setting>:<value>]*
bool firstEntry = true;
var sb = new System.Text.StringBuilder();
foreach (var kvp in bootConfigSettings)
{
if (!firstEntry)
{
sb.Append(";");
}
sb.Append($"{kvp.Key}:{kvp.Value}");
firstEntry = false;
}
EditorUserBuildSettings.SetPlatformSettings(buildTargetName, XrBootSettingsKey, sb.ToString());
}
}
public override int callbackOrder => 1;
public override Type featureType => typeof(MixedRealityFeaturePlugin);
protected override void OnPostGenerateGradleAndroidProjectExt(string path)
{
}
}
}
#endif

3
com.microsoft.mixedreality.openxr/Editor/BuildProcessors/MixedRealityBuildProcessor.cs.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e6ccea71264b4942ab62948680084dbb
timeCreated: 1590606496

8
com.microsoft.mixedreality.openxr/Editor/FeatureSets.meta Normal file
View File

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

38
com.microsoft.mixedreality.openxr/Editor/FeatureSets/AppRemotingFeatureSet.cs Normal file
View File

@ -0,0 +1,38 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using Microsoft.MixedReality.OpenXR.Remoting;
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[OpenXRFeatureSet(
FeatureSetId = featureSetId,
FeatureIds = new string[]
{
AppRemotingPlugin.featureId,
MixedRealityFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
},
RequiredFeatureIds = new string[]
{
AppRemotingPlugin.featureId,
MixedRealityFeaturePlugin.featureId,
},
DefaultFeatureIds = new string[]
{
AppRemotingPlugin.featureId,
MixedRealityFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
},
UiName = "Holographic Remoting remote app",
// This will appear as a tooltip for the (?) icon in the loader UI.
Description = "Enable the Holographic Remoting remote app features.",
SupportedBuildTargets = new BuildTargetGroup[] { BuildTargetGroup.Standalone, BuildTargetGroup.WSA }
)]
sealed class AppRemotingFeatureSet
{
internal const string featureSetId = "com.microsoft.openxr.featureset.appremoting";
}
}

11
com.microsoft.mixedreality.openxr/Editor/FeatureSets/AppRemotingFeatureSet.cs.meta Normal file
View File

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

36
com.microsoft.mixedreality.openxr/Editor/FeatureSets/HoloLensFeatureSet.cs Normal file
View File

@ -0,0 +1,36 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[OpenXRFeatureSet(
FeatureSetId = featureSetId,
FeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
MotionControllerFeaturePlugin.featureId,
},
RequiredFeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId,
},
DefaultFeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
MotionControllerFeaturePlugin.featureId,
},
UiName = "Microsoft HoloLens",
// This will appear as a tooltip for the (?) icon in the loader UI.
Description = "Enable the full suite of features for Microsoft HoloLens 2.",
SupportedBuildTargets = new BuildTargetGroup[] { BuildTargetGroup.WSA }
)]
sealed class HoloLensFeatureSet
{
internal const string featureSetId = "com.microsoft.openxr.featureset.hololens";
}
}

11
com.microsoft.mixedreality.openxr/Editor/FeatureSets/HoloLensFeatureSet.cs.meta Normal file
View File

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

36
com.microsoft.mixedreality.openxr/Editor/FeatureSets/WMRFeatureSet.cs Normal file
View File

@ -0,0 +1,36 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[OpenXRFeatureSet(
FeatureSetId = featureSetId,
FeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId,
MotionControllerFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
},
RequiredFeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId
},
DefaultFeatureIds = new string[]
{
MixedRealityFeaturePlugin.featureId,
MotionControllerFeaturePlugin.featureId,
HandTrackingFeaturePlugin.featureId,
},
UiName = "Windows Mixed Reality",
// This will appear as a tooltip for the (?) icon in the loader UI.
Description = "Enable the full suite of features for Windows Mixed Reality headsets.",
SupportedBuildTargets = new BuildTargetGroup[] { BuildTargetGroup.Standalone }
)]
sealed class WMRFeatureSet
{
internal const string featureSetId = "com.microsoft.openxr.featureset.wmr";
}
}

11
com.microsoft.mixedreality.openxr/Editor/FeatureSets/WMRFeatureSet.cs.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Editor/Inspectors.meta Normal file
View File

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

17
com.microsoft.mixedreality.openxr/Editor/Inspectors/EyeLevelSceneOriginInspector.cs Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEditor;
namespace Microsoft.MixedReality.OpenXR.Editor
{
#pragma warning disable CS0618
[CustomEditor(typeof(EyeLevelSceneOrigin))]
internal class EyeLevelSceneOriginInspector : UnityEditor.Editor
{
public override void OnInspectorGUI()
{
EditorGUILayout.HelpBox("Enable this override if the XR experience assumes the scene origin at eye level.", MessageType.Info);
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/Inspectors/EyeLevelSceneOriginInspector.cs.meta Normal file
View File

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

33
com.microsoft.mixedreality.openxr/Editor/Inspectors/PlayModeRemotingPluginInspector.cs Normal file
View File

@ -0,0 +1,33 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using Microsoft.MixedReality.OpenXR.Remoting;
using UnityEditor;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[CustomEditor(typeof(PlayModeRemotingPlugin))]
internal class PlayModeRemotingPluginInspector : UnityEditor.Editor
{
private PlayModeRemotingPlugin m_playModeRemotingPlugin;
private UnityEditor.Editor m_remotingSettingsEditor;
private void OnEnable()
{
m_playModeRemotingPlugin = target as PlayModeRemotingPlugin;
}
public override void OnInspectorGUI()
{
CreateCachedEditor(m_playModeRemotingPlugin.GetOrLoadRemotingSettings(), null, ref m_remotingSettingsEditor);
if (m_remotingSettingsEditor == null)
{
return;
}
EditorGUI.BeginDisabledGroup(EditorApplication.isPlaying);
m_remotingSettingsEditor.OnInspectorGUI();
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/Inspectors/PlayModeRemotingPluginInspector.cs.meta Normal file
View File

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

19
com.microsoft.mixedreality.openxr/Editor/Inspectors/RemotingSettingsInspector.cs Normal file
View File

@ -0,0 +1,19 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using Microsoft.MixedReality.OpenXR.Remoting;
using UnityEditor;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[CustomEditor(typeof(RemotingSettings))]
internal class RemotingSettingsInspector : UnityEditor.Editor
{
public override void OnInspectorGUI()
{
serializedObject.UpdateIfRequiredOrScript();
DrawPropertiesExcluding(serializedObject, new string[] { "m_Script" });
serializedObject.ApplyModifiedProperties();
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/Inspectors/RemotingSettingsInspector.cs.meta Normal file
View File

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

44
com.microsoft.mixedreality.openxr/Editor/Microsoft.MixedReality.OpenXR.Editor.asmdef Normal file
View File

@ -0,0 +1,44 @@
{
"name": "Microsoft.MixedReality.OpenXR.Editor",
"rootNamespace": "Microsoft.MixedReality.OpenXR.Editor",
"references": [
"Microsoft.MixedReality.OpenXR",
"Unity.XR.ARFoundation",
"Unity.XR.Management",
"Unity.XR.Management.Editor",
"Unity.XR.OpenXR",
"Unity.XR.OpenXR.Editor",
"Unity.XR.OpenXR.Features.MetaQuestSupport",
"Unity.XR.OpenXR.Features.OculusQuestSupport",
"UnityEngine.SpatialTracking",
"Unity.XR.CoreUtils.Editor",
"Unity.InputSystem"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [
{
"name": "com.unity.xr.arfoundation",
"expression": "3.0.0",
"define": "USE_ARFOUNDATION"
},
{
"name": "com.unity.xr.arfoundation",
"expression": "5.0.0",
"define": "USE_ARFOUNDATION_5_OR_NEWER"
},
{
"name": "com.unity.xr.openxr",
"expression": "1.6.0",
"define": "UNITY_OPENXR_1_6_OR_NEWER"
}
],
"noEngineReferences": false
}

7
com.microsoft.mixedreality.openxr/Editor/Microsoft.MixedReality.OpenXR.Editor.asmdef.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers.meta Normal file
View File

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

40
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/DocURLAttributeDrawer.cs Normal file
View File

@ -0,0 +1,40 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEditor;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[CustomPropertyDrawer(typeof(DocURLAttribute))]
internal class DocURLAttributeDrawer : PropertyDrawer
{
private static readonly GUIContent ButtonContent = new GUIContent(
string.Empty, EditorGUIUtility.IconContent("_Help").image, "Click for documentation");
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
DocURLAttribute labelWidthAttribute = attribute as DocURLAttribute;
if (!string.IsNullOrEmpty(labelWidthAttribute.Url))
{
using (new EditorGUILayout.HorizontalScope())
{
const float Spacing = 5f;
Vector2 size = EditorStyles.label.CalcSize(ButtonContent);
position.width -= size.x + Spacing;
EditorGUI.PropertyField(position, property, label);
position.x = position.width + Spacing;
position.width = size.x;
if (GUI.Button(position, ButtonContent, EditorStyles.label))
{
Help.BrowseURL(labelWidthAttribute.Url);
}
}
}
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/DocURLAttributeDrawer.cs.meta Normal file
View File

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

29
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/EditorDrawerVisibleToBuildTargetAttributeDrawer.cs Normal file
View File

@ -0,0 +1,29 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if UNITY_EDITOR
using System;
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[CustomPropertyDrawer(typeof(EditorDrawerVisibleToBuildTargetAttribute))]
internal class EditorDrawerVisibleToBuildTargetAttributeDrawer : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorDrawerVisibleToBuildTargetAttribute buildTargetAttribute = attribute as EditorDrawerVisibleToBuildTargetAttribute;
if (Array.Exists(buildTargetAttribute.BuildTargetGroups,
x => x == OpenXRFeatureSetManager.activeBuildTarget))
{
EditorGUI.PropertyField(position, property, label);
}
}
}
}
#endif

11
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/EditorDrawerVisibleToBuildTargetAttributeDrawer.cs.meta Normal file
View File

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

22
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/LabelWidthAttributeDrawer.cs Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEditor;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR.Editor
{
[CustomPropertyDrawer(typeof(LabelWidthAttribute))]
internal class LabelWidthAttributeDrawer : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
LabelWidthAttribute labelWidthAttribute = attribute as LabelWidthAttribute;
float oldLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = labelWidthAttribute.Width;
EditorGUI.PropertyField(position, property, label);
EditorGUIUtility.labelWidth = oldLabelWidth;
}
}
}

11
com.microsoft.mixedreality.openxr/Editor/PropertyDrawers/LabelWidthAttributeDrawer.cs.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Editor/Settings.meta Normal file
View File

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

752
com.microsoft.mixedreality.openxr/Editor/Settings/PlatformValidation.cs Normal file
View File

@ -0,0 +1,752 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if UNITY_EDITOR
using Microsoft.MixedReality.OpenXR.Remoting;
using System.Collections.Generic;
using System.Linq;
using Unity.XR.CoreUtils.Editor;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEditor.XR.Management.Metadata;
using UnityEditor.XR.OpenXR.Features;
using UnityEngine;
using UnityEngine.SpatialTracking;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;
using static Microsoft.MixedReality.OpenXR.MixedRealityFeaturePlugin;
namespace Microsoft.MixedReality.OpenXR.Editor
{
/// <summary>
/// Provides a menu item for configuring settings according to specified OpenXR devices.
/// </summary>
internal static class PlatformValidation
{
private static readonly IEnumerable<ValidationRuleset> ValidationRulesetsForRuleGeneration = ((ValidationRuleset[]) System.Enum.GetValues(typeof(ValidationRuleset))).Where((ruleset) => ruleset != ValidationRuleset.None);
private const string OpenXRProjectValidationSettingsPath = "Project/XR Plug-in Management/Project Validation";
private const string Win32StandaloneRulesetMenuPath = "Mixed Reality/Project Validation Settings/Win32 Application (Standalone)";
private const string HoloLens2RulesetMenuPath = "Mixed Reality/Project Validation Settings/HoloLens 2 Application (UWP)";
private const string Win32AppRemotingRulesetMenuPath = "Mixed Reality/Project Validation Settings/Win32 Remoting App for HoloLens 2 (Standalone)";
private const string UWPAppRemotingRulesetMenuPath = "Mixed Reality/Project Validation Settings/Win32 Remoting App for HoloLens 2 (UWP)";
private const string DisableValidationRulesetMenuPath = "Mixed Reality/Project Validation Settings/General Validation Rules Only";
private const string PerformanceHelpLinkText = "Click this icon for more info on recommended performance settings for HoloLens 2.";
private const string PerformanceHelpLink = "https://aka.ms/HoloLens2PerfSettings";
private const string SetupHelpLink = "https://aka.ms/HoloLens2OpenXRConfig";
private static readonly string CannotAutoSetupForHL2 = "Could not automatically apply recommended settings for HoloLens 2. " +
$"Please see {SetupHelpLink} for manual set up instructions";
private static readonly string CannotAutoOptimizeForHL2 = "Could not automatically apply recommended settings for HoloLens 2. " +
$"Please see {PerformanceHelpLink} for manual optimization instructions";
private const string AboutValidationRulesetsHelpText = "This rule has been enabled because a specific application type has been targeted for this project. \r\n" +
"To change or disable these additional validation rules, use the top-level menu:\r\n \"Mixed Reality > Project Validation Settings\"";
[InitializeOnLoadMethod]
private static void InitializePlatformValidation()
{
// These rules are generated for every validation ruleset on every platform - e.g. trying to validate HL2 apps on Standalone will redirect users to UWP.
BuildValidator.AddRules(BuildTargetGroup.WSA, GenerateBuildTargetRules(BuildTargetGroup.WSA));
BuildValidator.AddRules(BuildTargetGroup.Standalone, GenerateBuildTargetRules(BuildTargetGroup.Standalone));
// These rules are generated for every validation ruleset, but only on the platforms where each ruleset is supported.
// If a project is on the wrong platform, that needs to be fixed before these rules will show.
BuildValidator.AddRules(BuildTargetGroup.WSA, GenerateOpenXRLoaderRules(BuildTargetGroup.WSA));
BuildValidator.AddRules(BuildTargetGroup.Standalone, GenerateOpenXRLoaderRules(BuildTargetGroup.Standalone));
BuildValidator.AddRules(BuildTargetGroup.WSA, GenerateRequiredFeatureSetsRules(BuildTargetGroup.WSA));
BuildValidator.AddRules(BuildTargetGroup.Standalone, GenerateRequiredFeatureSetsRules(BuildTargetGroup.Standalone));
BuildValidator.AddRules(BuildTargetGroup.WSA, GenerateInitializeXROnStartRules(BuildTargetGroup.WSA));
BuildValidator.AddRules(BuildTargetGroup.Standalone, GenerateInitializeXROnStartRules(BuildTargetGroup.Standalone));
BuildValidator.AddRules(BuildTargetGroup.WSA, GenerateCameraRules());
// These rules are all HL2 specific, and are only enabled with the HL2 validation ruleset while targeting UWP.
BuildValidationRule[] wsaValidationRules = new BuildValidationRule[] { GenerateHL2RealtimeGIRule(), GenerateHL2QualityRule(),
GenerateHL2RenderAndDepthSubmissionModeRule() };
BuildValidator.AddRules(BuildTargetGroup.WSA, wsaValidationRules);
// These deprecation warnings are always enabled.
BuildValidationRule[] androidDeprecationRules = new BuildValidationRule[] { GenerateAndroidHandTrackingRule(), GenerateAndroidMotionControllerRule() };
BuildValidator.AddRules(BuildTargetGroup.Android, androidDeprecationRules);
}
private static void ChangeValidationRuleset(ValidationRuleset validationRuleset)
{
BuildTargetGroup buildTargetGroup = validationRuleset.GetBuildTargetGroup();
BuildTarget buildTarget = validationRuleset.GetBuildTarget();
string scenarioName = validationRuleset.GetScenarioName();
if (buildTargetGroup == BuildTargetGroup.WSA && !BuildPipeline.IsBuildTargetSupported(BuildTargetGroup.WSA, BuildTarget.WSAPlayer))
{
EditorUtility.DisplayDialog("UWP support not found", "The UWP build support is not currently installed. " +
"Please add the Universal Windows Platform Build Support module to your Unity installation.", "OK");
return;
}
BuildTargetGroup previousBuildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
// Make sure to select the correct platform, which also select the correct tab in the validation window.
// NOTE: must do this selected group change before switching build target below
// otherwise this selection change will not function properly in Unity editor.
if (EditorUserBuildSettings.selectedBuildTargetGroup != buildTargetGroup)
{
EditorUserBuildSettings.selectedBuildTargetGroup = buildTargetGroup;
}
if (EditorUserBuildSettings.activeBuildTarget != buildTarget)
{
if (EditorUtility.DisplayDialog("Change build target platform?", $"This project is currently targeting a platform which does not support {scenarioName} apps. " +
$"To build {scenarioName} applications, the build target platform in Build Settings must be {buildTarget}.\n\n" +
$"Click `Continue` to switch the build target platform to {buildTarget} and open the Project Validation window to review other validation messages.",
"Continue", "Cancel"))
{
EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildTarget);
}
else
{
EditorUserBuildSettings.selectedBuildTargetGroup = previousBuildTargetGroup;
return;
}
}
ValidationSettings.CurrentRuleset = validationRuleset;
ShowProjectValidationSettings();
}
private static void ShowProjectValidationSettings()
{
// Need to call OpenProjectSettings twice since the first call may not properly bring up the requested page
// Possibly due to the generation of XR settings related files on the fly
SettingsService.OpenProjectSettings(OpenXRProjectValidationSettingsPath);
EditorApplication.delayCall += () =>
{
SettingsService.OpenProjectSettings(OpenXRProjectValidationSettingsPath);
};
}
[MenuItem(Win32StandaloneRulesetMenuPath, isValidateFunction: false, priority: 10)]
private static void ChangeValidationRulesetWin32Standalone() =>
ChangeValidationRuleset(ValidationRuleset.Win32Standalone);
[MenuItem(Win32StandaloneRulesetMenuPath, isValidateFunction: true)]
private static bool ChangeValidationRulesetWin32StandaloneValidator() =>
UpdateRulesetMenuItemChecked(Win32StandaloneRulesetMenuPath, ValidationRuleset.Win32Standalone);
[MenuItem(HoloLens2RulesetMenuPath, isValidateFunction: false, priority: 11)]
private static void ChangeValidationRulesetHoloLens2() =>
ChangeValidationRuleset(ValidationRuleset.HoloLens2);
[MenuItem(HoloLens2RulesetMenuPath, isValidateFunction: true)]
private static bool ChangeValidationRulesetHoloLens2Validator() =>
UpdateRulesetMenuItemChecked(HoloLens2RulesetMenuPath, ValidationRuleset.HoloLens2);
[MenuItem(Win32AppRemotingRulesetMenuPath, isValidateFunction: false, priority: 12)]
private static void ChangeValidationRulesetWin32AppRemoting() =>
ChangeValidationRuleset(ValidationRuleset.Win32AppRemoting);
[MenuItem(Win32AppRemotingRulesetMenuPath, isValidateFunction: true)]
private static bool ChangeValidationRulesetWin32AppRemotingValidator() =>
UpdateRulesetMenuItemChecked(Win32AppRemotingRulesetMenuPath, ValidationRuleset.Win32AppRemoting);
[MenuItem(UWPAppRemotingRulesetMenuPath, isValidateFunction: false, priority: 13)]
private static void ChangeValidationRulesetUWPAppRemoting() =>
ChangeValidationRuleset(ValidationRuleset.UWPAppRemoting);
[MenuItem(UWPAppRemotingRulesetMenuPath, isValidateFunction: true)]
private static bool ChangeValidationRulesetUWPAppRemotingValidator() =>
UpdateRulesetMenuItemChecked(UWPAppRemotingRulesetMenuPath, ValidationRuleset.UWPAppRemoting);
// MenuItems with a difference in priority > 10 will have a horizontal line between them in the menu UI.
[MenuItem(DisableValidationRulesetMenuPath, isValidateFunction: false, priority: 25)]
private static void RemoveValidationRulesets() => ValidationSettings.CurrentRuleset = ValidationRuleset.None;
[MenuItem(DisableValidationRulesetMenuPath, isValidateFunction: true)]
private static bool RemoveValidationRulesetsValidator() =>
UpdateRulesetMenuItemChecked(DisableValidationRulesetMenuPath, ValidationRuleset.None);
#region Validation ruleset rules
private static BuildValidationRule[] GenerateBuildTargetRules(BuildTargetGroup buildTargetGroup)
{
List<BuildValidationRule> validationRules = new List<BuildValidationRule>();
foreach(ValidationRuleset validationRuleset in ValidationRulesetsForRuleGeneration)
{
if(validationRuleset.GetBuildTargetGroup() == buildTargetGroup)
{
// No need for a rule on this build target group, since it must already be correct
continue;
}
string scenarioName = validationRuleset.GetScenarioName();
string platformShortName = validationRuleset.GetPlatformShortName();
validationRules.Add(new BuildValidationRule()
{
// The build target should always be enabled if plugin validation has been enabled.
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == validationRuleset,
Category = $"Mixed Reality OpenXR - {scenarioName} Ruleset",
Message = $"The project needs to target the {platformShortName} platform to build {scenarioName} applications.",
CheckPredicate = () => EditorUserBuildSettings.activeBuildTarget == validationRuleset.GetBuildTarget(),
FixIt = () => {
EditorUserBuildSettings.selectedBuildTargetGroup = validationRuleset.GetBuildTargetGroup();
EditorUserBuildSettings.SwitchActiveBuildTarget(validationRuleset.GetBuildTargetGroup(), validationRuleset.GetBuildTarget());
},
FixItMessage = $"Switch the build target to {platformShortName}",
Error = true,
FixItAutomatic = true,
HelpText = AboutValidationRulesetsHelpText
});
}
return validationRules.ToArray();
}
private static BuildValidationRule[] GenerateOpenXRLoaderRules(BuildTargetGroup buildTargetGroup)
{
List<BuildValidationRule> validationRules = new List<BuildValidationRule>();
foreach(ValidationRuleset validationRuleset in ValidationRulesetsForRuleGeneration)
{
if(validationRuleset.GetBuildTargetGroup() != buildTargetGroup)
{
continue;
}
string scenarioName = validationRuleset.GetScenarioName();
string platformShortName = validationRuleset.GetPlatformShortName();
validationRules.Add(new BuildValidationRule()
{
// The OpenXR loader should always be enabled if a validation ruleset has been enabled.
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == validationRuleset,
Category = $"Mixed Reality OpenXR - {scenarioName} Ruleset",
Message = $"For {scenarioName} applications, the OpenXR loader must be enabled for {platformShortName} in XR plugin management settings.",
CheckPredicate = () => XRPackageMetadataStore.IsLoaderAssigned(typeof(OpenXRLoader).FullName, buildTargetGroup),
FixIt = () => EnableOpenXRLoader(buildTargetGroup),
FixItMessage = $"Assign the OpenXR loader for {platformShortName}",
Error = false,
HelpText = AboutValidationRulesetsHelpText
});
}
return validationRules.ToArray();
}
private static BuildValidationRule[] GenerateRequiredFeatureSetsRules(BuildTargetGroup buildTargetGroup)
{
List<BuildValidationRule> validationRules = new List<BuildValidationRule>();
foreach (ValidationRuleset validationRuleset in ValidationRulesetsForRuleGeneration)
{
if (validationRuleset.GetBuildTargetGroup() != buildTargetGroup)
{
continue;
}
string scenarioName = validationRuleset.GetScenarioName();
string platformShortName = validationRuleset.GetPlatformShortName();
System.Type[] featureSets = validationRuleset.GetRequiredFeatureSets();
List<string> featureSetUINames = new List<string>();
List<string> featureSetIds = new List<string>();
GetIdsAndUserNamesForFeatureSets(featureSets, ref featureSetIds, ref featureSetUINames);
validationRules.Add(new BuildValidationRule()
{
// The necessary feature set should always be enabled if a validation ruleset has been enabled.
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == validationRuleset,
Category = $"Mixed Reality OpenXR - {scenarioName} Ruleset",
Message = $"For {scenarioName} apps, the following feature sets must be enabled for {platformShortName} in OpenXR settings: {string.Join(", ", featureSetUINames)}",
CheckPredicate = () => CheckFeatureSets(buildTargetGroup, featureSetIds),
FixIt = () => EnableFeatureSets(buildTargetGroup, featureSetIds),
FixItMessage = $"Enable the following feature sets for {platformShortName}: {string.Join(", ", featureSetUINames)}",
Error = true,
HelpText = AboutValidationRulesetsHelpText
});
System.Type[] notRequiredfeatureSets = validationRuleset.GetNotRequiredFeatureSets();
List<string> notRequiredFeatureSetUINames = new List<string>();
List<string> notRequiredFeatureSetIds = new List<string>();
GetIdsAndUserNamesForFeatureSets(notRequiredfeatureSets, ref notRequiredFeatureSetIds, ref notRequiredFeatureSetUINames);
if (notRequiredFeatureSetIds.Count > 0)
{
validationRules.Add(new BuildValidationRule()
{
// The necessary feature set should always be enabled if a validation ruleset has been enabled.
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == validationRuleset,
Category = $"Mixed Reality OpenXR - {scenarioName} Ruleset",
Message = $"For {scenarioName} apps, the following feature sets must be disabled for {platformShortName} in OpenXR settings: {string.Join(", ", notRequiredFeatureSetUINames)}",
CheckPredicate = () => !CheckFeatureSets(buildTargetGroup, notRequiredFeatureSetIds),
FixIt = () => DisableFeatureSets(buildTargetGroup, notRequiredFeatureSetIds),
FixItMessage = $"Disable the following feature sets for {platformShortName}: {string.Join(", ", notRequiredFeatureSetUINames)}",
Error = true,
HelpText = AboutValidationRulesetsHelpText
});
}
}
return validationRules.ToArray();
}
private static BuildValidationRule[] GenerateInitializeXROnStartRules(BuildTargetGroup buildTargetGroup)
{
List<BuildValidationRule> validationRules = new List<BuildValidationRule>();
foreach (ValidationRuleset validationRuleset in ValidationRulesetsForRuleGeneration)
{
if (validationRuleset.GetBuildTargetGroup() != buildTargetGroup)
{
continue;
}
string scenarioName = validationRuleset.GetScenarioName();
string platformShortName = validationRuleset.GetPlatformShortName();
bool remotingEnabled = validationRuleset.GetRemotingEnabled();
validationRules.Add(new BuildValidationRule()
{
// This rule will run if a validation ruleset has been enabled. If there is no validation ruleset, we fallback to the validator in AppRemotingValidator.cs
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == validationRuleset,
Category = $"Mixed Reality OpenXR - {scenarioName} Ruleset",
Message = $"For {scenarioName} applications, XR initialization should {(remotingEnabled ? "be delayed until a specific IP address is entered" : "not be delayed")}",
CheckPredicate = () =>
{
XRGeneralSettings settings = XRSettingsHelpers.GetOrCreateXRGeneralSettings(buildTargetGroup);
return settings != null && settings.InitManagerOnStart != remotingEnabled;
},
FixIt = () =>
{
XRGeneralSettings settings = XRSettingsHelpers.GetOrCreateXRGeneralSettings(buildTargetGroup);
if (settings != null)
{
settings.InitManagerOnStart = !remotingEnabled;
}
},
FixItMessage = $"{ (remotingEnabled ? "Disable" : "Enable") } XR initialization on startup",
// If remoting is enabled, this must be enabled. If remoting is not enabled, this should likely be disabled, but it's not required.
Error = remotingEnabled,
HelpText = AboutValidationRulesetsHelpText
});
}
return validationRules.ToArray();
}
#endregion
#region HoloLens 2 rules
private static BuildValidationRule GenerateHL2RealtimeGIRule()
{
return new BuildValidationRule()
{
IsRuleEnabled = IsHL2RulesetEnabled,
Category = "Mixed Reality OpenXR - HoloLens 2 Ruleset",
Message = $"Realtime GI has a negative performance impact on HoloLens 2 applications.",
CheckPredicate = () => !Lightmapping.TryGetLightingSettings(out LightingSettings lightingSettings) || !lightingSettings.realtimeGI,
FixIt = () =>
{
if (Lightmapping.TryGetLightingSettings(out LightingSettings lightingSettings))
{
lightingSettings.realtimeGI = false;
EditorUtility.SetDirty(lightingSettings);
}
else
{
Debug.LogError(CannotAutoOptimizeForHL2);
}
},
FixItMessage = $"Disable realtime GI in lighting settings",
Error = false,
HelpText = PerformanceHelpLinkText + "\r\n\r\n" + AboutValidationRulesetsHelpText,
HelpLink = PerformanceHelpLink
};
}
private static BuildValidationRule GenerateHL2QualityRule()
{
return new BuildValidationRule()
{
// Currently this rule doesn't work as Unity use the "default quality" for a platform to determine the quality level to use
// Setting the "current active quality" does not impact the application running on HoloLens 2
IsRuleEnabled = () => false,
Category = "Mixed Reality OpenXR - HoloLens 2 Ruleset",
Message = $"High quality settings have a negative performance impact on HoloLens 2 applications.",
CheckPredicate = () => QualitySettings.GetQualityLevel() == 0,
FixIt = () => QualitySettings.SetQualityLevel(0, true),
FixItMessage = $"Set quality settings to very low",
Error = false,
HelpText = PerformanceHelpLinkText + "\r\n\r\n" + AboutValidationRulesetsHelpText,
HelpLink = PerformanceHelpLink
};
}
private static BuildValidationRule GenerateHL2GPUSkinningRule()
{
return new BuildValidationRule()
{
IsRuleEnabled = IsHL2RulesetEnabled,
Category = "Mixed Reality OpenXR - HoloLens 2 Ruleset",
Message = $"GPU skinning negatively impacts the performance of HoloLens 2 applications.",
CheckPredicate = () => !PlayerSettings.gpuSkinning,
FixIt = () => PlayerSettings.gpuSkinning = false,
FixItMessage = $"Disable GPU skinning",
Error = false,
HelpText = PerformanceHelpLinkText + "\r\n\r\n" + AboutValidationRulesetsHelpText,
HelpLink = PerformanceHelpLink
};
}
private static BuildValidationRule GenerateHL2RenderAndDepthSubmissionModeRule()
{
return new BuildValidationRule()
{
IsRuleEnabled = IsHL2RulesetEnabled,
Category = "Mixed Reality OpenXR - HoloLens 2 Ruleset",
Message = $"Single pass instanced is recommended for render mode and depth 16 bit is recommended for depth submission mode settings.",
CheckPredicate = () =>
{
if (TryGetOpenXRSetting(BuildTargetGroup.WSA, out OpenXRSettings settings))
{
return settings.depthSubmissionMode == OpenXRSettings.DepthSubmissionMode.Depth16Bit && settings.renderMode == OpenXRSettings.RenderMode.SinglePassInstanced;
}
return true;
},
FixIt = () =>
{
if (TryGetOpenXRSetting(BuildTargetGroup.WSA, out OpenXRSettings settings))
{
settings.depthSubmissionMode = OpenXRSettings.DepthSubmissionMode.Depth16Bit;
settings.renderMode = OpenXRSettings.RenderMode.SinglePassInstanced;
EditorUtility.SetDirty(settings);
}
else
{
Debug.LogError(CannotAutoOptimizeForHL2);
}
},
FixItMessage = $"Switch the render mode to single pass instanced and depth submission mode to depth 16 bit",
Error = false,
HelpText = PerformanceHelpLinkText + "\r\n\r\n" + AboutValidationRulesetsHelpText,
HelpLink = PerformanceHelpLink
};
}
#endregion HoloLens 2 rules
#region Camera setup rules
// Guidelines for using a camera which will render output for a HoloLens 2
private static BuildValidationRule[] GenerateCameraRules()
{
return new BuildValidationRule[] { GenerateCameraFlagsRule(ValidationRuleset.HoloLens2), GenerateCameraFlagsRule(ValidationRuleset.UWPAppRemoting),
GenerateCameraBackgroundColorRule(ValidationRuleset.HoloLens2), GenerateCameraBackgroundColorRule(ValidationRuleset.UWPAppRemoting),
GenerateCameraPoseDriverRule(ValidationRuleset.HoloLens2), GenerateCameraPoseDriverRule(ValidationRuleset.UWPAppRemoting) };
}
private static BuildValidationRule GenerateCameraFlagsRule(ValidationRuleset targetRuleset)
{
return new BuildValidationRule()
{
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == targetRuleset,
Category = $"Mixed Reality OpenXR - {targetRuleset.GetScenarioName()} Ruleset (Scene specific)",
Message = $"It is recommended for the main camera to be cleared with a solid color.",
CheckPredicate = () => Camera.main == null || Camera.main.clearFlags == CameraClearFlags.SolidColor,
FixIt = () =>
{
Camera.main.clearFlags = CameraClearFlags.SolidColor;
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
},
FixItMessage = $"Set the main camera's clearFlags to CameraClearFlags.SolidColor",
Error = false,
FixItAutomatic = false,
SceneOnlyValidation = true,
HelpText = AboutValidationRulesetsHelpText
};
}
private static BuildValidationRule GenerateCameraBackgroundColorRule(ValidationRuleset targetRuleset)
{
return new BuildValidationRule()
{
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == targetRuleset,
Category = $"Mixed Reality OpenXR - {targetRuleset.GetScenarioName()} Ruleset (Scene specific)",
Message = $"It is recommended for the main camera to have a clear background color.",
CheckPredicate = () => Camera.main == null || Camera.main.backgroundColor == Color.clear,
FixIt = () =>
{
Camera.main.backgroundColor = Color.clear;
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
},
FixItMessage = $"Set the main camera background color to clear",
Error = false,
FixItAutomatic = false,
SceneOnlyValidation = true,
HelpText = AboutValidationRulesetsHelpText
};
}
private static BuildValidationRule GenerateCameraPoseDriverRule(ValidationRuleset targetRuleset)
{
return new BuildValidationRule()
{
IsRuleEnabled = () => ValidationSettings.CurrentRuleset == targetRuleset,
Category = $"Mixed Reality OpenXR - {targetRuleset.GetScenarioName()} Ruleset (Scene specific)",
Message = $"It is recommended for the main camera to have a PoseDriver component.",
CheckPredicate = () =>
Camera.main == null
|| Camera.main.gameObject.GetComponent<UnityEngine.SpatialTracking.TrackedPoseDriver>() != null
|| Camera.main.gameObject.GetComponent<UnityEngine.InputSystem.XR.TrackedPoseDriver>() != null
#if USE_ARFOUNDATION && !USE_ARFOUNDATION_5_OR_NEWER
|| Camera.main.gameObject.GetComponent<UnityEngine.XR.ARFoundation.ARPoseDriver>() != null
#endif
,
FixIt = () =>
{
if (Camera.main != null
&& !Camera.main.gameObject.GetComponent<UnityEngine.SpatialTracking.TrackedPoseDriver>()
&& !Camera.main.gameObject.GetComponent<UnityEngine.InputSystem.XR.TrackedPoseDriver>()
#if USE_ARFOUNDATION && !USE_ARFOUNDATION_5_OR_NEWER
&& !Camera.main.gameObject.GetComponent<UnityEngine.XR.ARFoundation.ARPoseDriver>()
#endif
)
{
Camera.main.gameObject.AddComponent<UnityEngine.SpatialTracking.TrackedPoseDriver>();
}
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
},
FixItMessage = $"Ensure the main camera has a PoseDriver component",
Error = false,
FixItAutomatic = false,
SceneOnlyValidation = true,
HelpText = AboutValidationRulesetsHelpText
};
}
#endregion
#region Android rules
private static BuildValidationRule GenerateAndroidHandTrackingRule()
{
var handTrackingFeaturePlugins = new System.Type[] { typeof(HandTrackingFeaturePlugin) };
return new BuildValidationRule()
{
IsRuleEnabled = () => true,
Category = "Mixed Reality OpenXR - Android",
Message = $"Hand tracking on Android with the Mixed Reality OpenXR Plugin has been deprecated. " +
"For Android applications using hand tracking, we recommend transitioning to the OpenXR plugins from Unity and Meta.",
CheckPredicate = () => !CheckFeatures(BuildTargetGroup.Android, handTrackingFeaturePlugins),
FixIt = () => SettingsService.OpenProjectSettings("Project/XR Plug-in Management/OpenXR"),
FixItMessage = $"Open Project Settings to disable the Hand Tracking feature for the Android build target.",
FixItAutomatic = false,
Error = false,
HelpText = AboutValidationRulesetsHelpText
};
}
private static BuildValidationRule GenerateAndroidMotionControllerRule()
{
var motionControllerFeaturePlugins = new System.Type[] { typeof(MotionControllerFeaturePlugin) };
return new BuildValidationRule()
{
IsRuleEnabled = () => true,
Category = "Mixed Reality OpenXR - Android",
Message = $"The Motion Controller Model feature plugin from the Mixed Reality OpenXR Plugin has been deprecated on Android. " +
"For Android applications using motion controller models, we recommend transitioning to the OpenXR plugins from Unity and Meta.",
CheckPredicate = () => !CheckFeatures(BuildTargetGroup.Android, motionControllerFeaturePlugins),
FixIt = () => SettingsService.OpenProjectSettings("Project/XR Plug-in Management/OpenXR"),
FixItMessage = $"Open Project Settings to disable the Motion Controller feature for the Android build target.",
FixItAutomatic = false,
Error = false,
HelpText = AboutValidationRulesetsHelpText
};
}
#endregion Android rules
#region Helpers
private static bool UpdateRulesetMenuItemChecked(string menuPath, ValidationRuleset ruleset)
{
Menu.SetChecked(menuPath, ValidationSettings.CurrentRuleset == ruleset);
return true;
}
private static bool IsHL2RulesetEnabled()
{
// Ensure the OpenXR loader is enabled on WSA - otherwise this is a flat UWP app on HL2 that shouldn't be validated with XR rules.
XRGeneralSettings wsaSettings = XRSettingsHelpers.GetOrCreateXRGeneralSettings(BuildTargetGroup.WSA);
if (!wsaSettings.Manager.activeLoaders.Any(loader => loader is UnityEngine.XR.OpenXR.OpenXRLoader))
{
return false;
}
// Ensure the HL2 feature plugin is enabled, with ValidationRuleTarget == HL2 - otherwise these specific rules are not necessary.
MixedRealityFeaturePlugin plugin = BuildProcessorHelpers.GetOpenXRFeature<MixedRealityFeaturePlugin>(BuildTargetGroup.WSA, false);
return plugin != null && plugin.enabled && (ValidationSettings.CurrentRuleset == ValidationRuleset.HoloLens2);
}
private static void EnableOpenXRLoader(BuildTargetGroup targetGroup)
{
if (XRSettingsHelpers.GetOrCreateXRManagerSettings(targetGroup) is XRManagerSettings settings && settings != null
&& XRPackageMetadataStore.AssignLoader(settings, nameof(OpenXRLoader), targetGroup))
{
EditorUtility.SetDirty(settings);
}
else
{
Debug.LogError(CannotAutoSetupForHL2);
}
}
private static bool CheckFeatureSets(BuildTargetGroup targetGroup, List<string> featureIds)
{
if (XRSettingsHelpers.GetOrCreateXRManagerSettings(targetGroup) is XRManagerSettings settings && settings != null)
{
foreach (var featureSet in OpenXRFeatureSetManager.FeatureSetsForBuildTarget(targetGroup))
{
if (featureIds.Contains(featureSet.featureSetId) && !featureSet.isEnabled)
{
return false;
}
}
}
return true;
}
private static void EnableFeatureSets(BuildTargetGroup targetGroup, List<string> featureIds)
{
foreach (var featureSet in OpenXRFeatureSetManager.FeatureSetsForBuildTarget(targetGroup))
{
if (featureIds.Contains(featureSet.featureSetId) && !featureSet.isEnabled)
{
featureSet.isEnabled = true;
}
}
OpenXRFeatureSetManager.SetFeaturesFromEnabledFeatureSets(targetGroup);
}
private static void DisableFeatureSets(BuildTargetGroup targetGroup, List<string> featureIds)
{
foreach (var featureSet in OpenXRFeatureSetManager.FeatureSetsForBuildTarget(targetGroup))
{
if (featureIds.Contains(featureSet.featureSetId) && featureSet.isEnabled)
{
featureSet.isEnabled = false;
}
}
OpenXRFeatureSetManager.SetFeaturesFromEnabledFeatureSets(targetGroup);
}
// This extension method must be defined from within the Editor package, as it depends on the feature set types.
internal static System.Type[] GetRequiredFeatureSets(this ValidationRuleset validationRuleset)
{
switch (validationRuleset)
{
case ValidationRuleset.Win32Standalone:
return new System.Type[] { typeof(WMRFeatureSet) };
case ValidationRuleset.HoloLens2:
return new System.Type[] { typeof(HoloLensFeatureSet) };
case ValidationRuleset.Win32AppRemoting:
return new System.Type[] { typeof(AppRemotingFeatureSet) };
case ValidationRuleset.UWPAppRemoting:
return new System.Type[] { typeof(AppRemotingFeatureSet) };
}
Debug.LogError($"RequiredFeatureSets of ValidationRuleset \"{validationRuleset}\" are not defined.");
return new System.Type[] { };
}
internal static System.Type[] GetNotRequiredFeatureSets(this ValidationRuleset validationRuleset)
{
switch (validationRuleset)
{
case ValidationRuleset.Win32Standalone:
return new System.Type[] { typeof(AppRemotingFeatureSet) };
case ValidationRuleset.HoloLens2:
return new System.Type[] { typeof(AppRemotingFeatureSet) };
case ValidationRuleset.Win32AppRemoting:
return new System.Type[] { };
case ValidationRuleset.UWPAppRemoting:
return new System.Type[] { };
}
Debug.LogError($"RequiredFeatureSets of ValidationRuleset \"{validationRuleset}\" are not defined.");
return new System.Type[] { };
}
private static bool TryGetOpenXRSetting(BuildTargetGroup targetGroup, out OpenXRSettings openXRSettings)
{
if (EditorBuildSettings.TryGetConfigObject(Constants.k_SettingsKey, out Object obj) && obj is IPackageSettings packageSettings
&& packageSettings.GetSettingsForBuildTargetGroup(targetGroup) is OpenXRSettings settings && settings != null)
{
openXRSettings = settings;
return true;
}
else
{
openXRSettings = null;
return false;
}
}
private static bool CheckFeatures(BuildTargetGroup targetGroup, IEnumerable<System.Type> featureTypes)
{
if (TryGetOpenXRSetting(targetGroup, out OpenXRSettings settings))
{
foreach (OpenXRFeature feature in settings.GetFeatures())
{
if (featureTypes.Contains(feature.GetType()) && !feature.enabled)
{
return false;
}
}
}
return true;
}
private static void EnableFeatures(BuildTargetGroup targetGroup, IEnumerable<System.Type> featureTypes)
{
if (TryGetOpenXRSetting(targetGroup, out OpenXRSettings settings))
{
foreach (OpenXRFeature feature in settings.GetFeatures())
{
if (featureTypes.Contains(feature.GetType()) && !feature.enabled)
{
feature.enabled = true;
}
}
EditorUtility.SetDirty(settings);
}
}
private static void GetIdsAndUserNamesForFeatureSets(System.Type[] featureSets, ref List<string> featureSetIds, ref List<string> featureSetUINames)
{
for(int i = 0; i < featureSets.Length; i++) {
var attribute = featureSets[i].GetCustomAttributes(typeof(OpenXRFeatureSetAttribute), true).FirstOrDefault() as OpenXRFeatureSetAttribute;
if (attribute == null)
{
Debug.LogError($"Could not generate Mixed Reality OpenXR feature set validator - feature set attribute not found for {featureSets[i]}");
continue;
}
featureSetIds.Add(attribute.FeatureSetId);
featureSetUINames.Add(attribute.UiName);
}
}
#endregion Helpers
}
}
#endif

11
com.microsoft.mixedreality.openxr/Editor/Settings/PlatformValidation.cs.meta Normal file
View File

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

120
com.microsoft.mixedreality.openxr/Editor/Settings/PlayModeRemotingWindow.cs Normal file
View File

@ -0,0 +1,120 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if UNITY_EDITOR
using Microsoft.MixedReality.OpenXR.Remoting;
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
using UnityEngine;
using UnityEngine.XR.OpenXR;
namespace Microsoft.MixedReality.OpenXR.Editor
{
/// <summary>
/// Represents a standalone window for accessing holographic remoting for play mode settings.
/// </summary>
internal class PlayModeRemotingWindow : EditorWindow
{
private static PlayModeRemotingPlugin Feature => OpenXRFeaturePlugin<PlayModeRemotingPlugin>.Feature;
private const string ConnectionInfo = "Clicking the \"Play\" button will connect Unity editor to the Holographic Remoting Player running on above IP address.";
private static readonly GUIContent FeatureEnabledLabel = EditorGUIUtility.TrTextContent($"Disable {PlayModeRemotingPlugin.featureName}");
private static readonly GUIContent FeatureDisabledLabel = EditorGUIUtility.TrTextContent($"Enable {PlayModeRemotingPlugin.featureName}");
private static readonly GUIContent FixLabel = EditorGUIUtility.TrTextContent("Fix");
private UnityEditor.Editor m_playModeRemotingPluginEditor;
private Vector2 m_scrollPos;
/// <summary>
/// Initializes the Remoting Window class
/// </summary>
[MenuItem(PlayModeRemotingValidator.PlayModeRemotingMenuPath)]
[MenuItem(PlayModeRemotingValidator.PlayModeRemotingMenuPath2)]
private static void Init()
{
GetWindow<PlayModeRemotingWindow>(PlayModeRemotingPlugin.featureName);
}
private void OnGUI()
{
using (var scroll = new EditorGUILayout.ScrollViewScope(m_scrollPos))
{
m_scrollPos = scroll.scrollPosition;
if (Feature == null)
{
FeatureHelpers.RefreshFeatures(BuildTargetGroup.Standalone);
}
UnityEditor.Editor.CreateCachedEditor(Feature, null, ref m_playModeRemotingPluginEditor);
if (m_playModeRemotingPluginEditor == null)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox($"An instance of {PlayModeRemotingPlugin.featureName} could not be found. Please open Project Settings > XR Plug-in Management > OpenXR to ensure it's properly loaded.", MessageType.Error);
return;
}
EditorGUILayout.Space();
m_playModeRemotingPluginEditor.OnInspectorGUI();
if (Feature.IsValidAndEnabled())
{
EditorGUILayout.Space();
bool hasValidSettings = Feature.HasValidSettings();
bool isLoaderAssigned = PlayModeRemotingValidator.IsLoaderAssigned();
bool areDependenciesEnabled = PlayModeRemotingValidator.AreDependenciesEnabled();
if (hasValidSettings && isLoaderAssigned && areDependenciesEnabled)
{
EditorGUILayout.HelpBox(ConnectionInfo, MessageType.Info);
}
else
{
if (!hasValidSettings)
{
EditorGUILayout.HelpBox(PlayModeRemotingValidator.RemotingNotConfigured, MessageType.Error);
}
if (!isLoaderAssigned)
{
EditorGUILayout.HelpBox(PlayModeRemotingValidator.OpenXRLoaderNotAssigned, MessageType.Error);
if (GUILayout.Button(FixLabel))
{
PlayModeRemotingValidator.AssignLoader();
}
}
if (!areDependenciesEnabled)
{
EditorGUILayout.HelpBox(PlayModeRemotingValidator.DependenciesNotEnabled, MessageType.Error);
if (GUILayout.Button(FixLabel))
{
PlayModeRemotingValidator.EnableDependencies();
}
}
}
}
// Disable the "enable/disable" button when editor is already playing
using (new EditorGUI.DisabledScope(EditorApplication.isPlaying))
{
EditorGUILayout.Space();
if (GUILayout.Button(Feature.enabled ? FeatureEnabledLabel : FeatureDisabledLabel))
{
Feature.enabled = !Feature.enabled;
if (Feature.enabled)
{
// If the user turned on the feature, try to enable dependencies as well.
PlayModeRemotingValidator.EnableDependencies();
}
}
}
}
}
}
}
#endif

11
com.microsoft.mixedreality.openxr/Editor/Settings/PlayModeRemotingWindow.cs.meta Normal file
View File

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

21
com.microsoft.mixedreality.openxr/LICENSE.md Normal file
View File

@ -0,0 +1,21 @@
Copyright (c) Microsoft Corporation.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

7
com.microsoft.mixedreality.openxr/LICENSE.md.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Runtime.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Runtime/API.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker.meta Normal file
View File

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

179
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarker.cs Normal file
View File

@ -0,0 +1,179 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using Microsoft.MixedReality.OpenXR.ARSubsystems;
using System;
using Unity.Collections;
using UnityEngine;
using UnityEngine.XR.ARFoundation;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Types of markers that can be tracked.
/// </summary>
public enum ARMarkerType
{
/// <summary>
/// A marker of QRCode type.
/// Equivalent to XR_SCENE_MARKER_TYPE_QR_CODE_MSFT.
/// </summary>
QRCode = 1
}
/// <summary>
/// Represents types of QRCodes that can be detected.
/// </summary>
public enum QRCodeType
{
/// <summary>
/// A QRCode type of QRCode.
/// Equivalent to XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT.
/// </summary>
QRCode = 1,
/// <summary>
/// A QRCode type of MicroQRCode.
/// Equivalent to XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT.
/// </summary>
MicroQRCode = 2
}
/// <summary>
/// Types of transforms that can be applied to markers.
/// </summary>
public enum TransformMode
{
/// <summary>
/// Marker centered at origin.
/// </summary>
MostStable = 0,
/// <summary>
/// Marker centered at geometric center.
/// </summary>
Center = 1,
}
/// <summary>
/// Represents properties of detected QRCodes.
/// </summary>
/// <remarks>See https://github.com/yansikeim/QR-Code/blob/master/ISO%20IEC%2018004%202015%20Standard.pdf for more information.</remarks>
public struct QRCodeProperties
{
/// <summary>
/// Version of the QRCode.
/// </summary>
/// <remarks>
/// The version is in the range of 1-40 if the type is QRCode.
/// The version is in the range or 1-4 if the type is microQRCode.
/// </remarks>
public uint version;
/// <summary>
/// Type of the QRCode.
/// </summary>
public QRCodeType type;
}
/// <summary>
/// Represents a marker detected by an AR device.
/// </summary>
/// <remarks>
/// Generated by the <see cref="ARMarkerManager"/> when an AR device detects
/// a marker in the environment.
/// </remarks>
[DefaultExecutionOrder(ARUpdateOrder.k_Plane)]
[DisallowMultipleComponent]
public sealed class ARMarker : ARTrackable<XRMarker, ARMarker>
{
/// <summary>
/// The time when the marker was last seen. Comparable to <see cref="Time.realtimeSinceStartup"/>.
/// </summary>
public float lastSeenTime => sessionRelativeData.lastSeenTime;
/// <summary>
/// The center relative to the pose in the X, Y plane.
/// </summary>
public Vector2 center => sessionRelativeData.center;
/// <summary>
/// The physical size (dimensions) of the marker in meters.
/// </summary>
public Vector2 size => sessionRelativeData.size;
/// <summary>
/// The type of marker. Currently we only support markert os QRCode type.
/// </summary>
public ARMarkerType markerType => sessionRelativeData.markerType;
/// <summary>
/// The type of transform to apply on the marker.
/// </summary>
public TransformMode transformMode
{
get => sessionRelativeData.transformMode;
set
{
if (ARMarkerManager.Instance != null)
{
ARMarkerManager.Instance.SetTransformMode(trackableId, value);
}
}
}
/// <summary>
/// Get a native pointer associated with this marker.
/// </summary>
/// <remarks>
/// The data pointed to by this member is implementation defined.
/// The lifetime of the pointed to object is also
/// implementation defined, but should be valid at least until the next
/// <see cref="ARSession"/> update.
/// </remarks>
public IntPtr nativePtr => sessionRelativeData.nativePtr;
/// <summary>
/// Get the decoded string associated with this marker.
/// </summary>
public string GetDecodedString()
{
if (ARMarkerManager.Instance != null)
{
return ARMarkerManager.Instance.GetDecodedString(trackableId);
}
return string.Empty;
}
/// <summary>
/// Get the raw data associated with this marker.
/// </summary>
public NativeArray<byte> GetRawData(Allocator allocator)
{
if (ARMarkerManager.Instance != null)
{
return ARMarkerManager.Instance.GetRawData(trackableId, allocator);
}
return new NativeArray<byte>(0, allocator);
}
/// <summary>
/// Get the properties associated with this QRCode marker.
/// </summary>
public QRCodeProperties GetQRCodeProperties()
{
if (markerType == ARMarkerType.QRCode)
{
if (ARMarkerManager.Instance != null)
{
return ARMarkerManager.Instance.GetQRCodeProperties(trackableId);
}
return new QRCodeProperties();
}
else
{
throw new InvalidOperationException("GetQRCodeProperties() is only valid when markerType == ARMarkerType.QRCode");
}
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarker.cs.meta Normal file
View File

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

183
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkerManager.cs Normal file
View File

@ -0,0 +1,183 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using Microsoft.MixedReality.OpenXR.ARSubsystems;
using System;
using System.Collections.Generic;
using System.Linq;
using Unity.Collections;
using Unity.XR.CoreUtils;
using UnityEngine;
using UnityEngine.XR.ARFoundation;
using UnityEngine.XR.ARSubsystems;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// A manager for <see cref="ARMarker"/>s. Creates, updates, and removes
/// <c>GameObject</c>s in response to detected surfaces in the physical
/// environment.
/// </summary>
[DefaultExecutionOrder(ARUpdateOrder.k_PlaneManager)]
[DisallowMultipleComponent]
#if USE_ARFOUNDATION_5_OR_NEWER
[RequireComponent(typeof(XROrigin))]
#else
[RequireComponent(typeof(ARSessionOrigin))]
#endif
public sealed class ARMarkerManager : ARTrackableManager<
XRMarkerSubsystem,
XRMarkerSubsystemDescriptor,
XRMarkerSubsystem.Provider,
XRMarker,
ARMarker>
{
private static ARMarkerManager m_instance = null;
/// <summary>
/// Singleton instance for ARMarkerManager
/// </summary>
public static ARMarkerManager Instance => m_instance;
/// <summary>
/// Getter or setter for the Marker Prefab.
/// </summary>
[Tooltip("If not null, instantiates this prefab for each created marker. Else, a default empty GameObject is created with the new ARMarker attached.")]
public GameObject markerPrefab;
/// <summary>
/// The list of <see cref="ARMarkerType"/>s that will be detected.
/// </summary>
[Tooltip("The list of ARMarker types that will be detected.")]
public ARMarkerType[] enabledMarkerTypes = { ARMarkerType.QRCode };
/// <summary>
/// Default <see cref="TransformMode"/> for newly detected markers.
/// </summary>
[Tooltip("Default transform mode for newly detected markers.")]
public TransformMode defaultTransformMode = TransformMode.MostStable;
/// <summary>
/// Invoked when markers have changed (been added, updated, or removed).
/// </summary>
public event Action<ARMarkersChangedEventArgs> markersChanged;
/// <summary>
/// Attempt to retrieve an existing <see cref="ARMarker"/> by <paramref name="trackableId"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker to retrieve.</param>
/// <returns>The <see cref="ARMarker"/> with <paramref name="trackableId"/>, or <c>null</c> if it does not exist.</returns>
public ARMarker GetMarker(TrackableId trackableId) => m_Trackables.TryGetValue(trackableId, out ARMarker marker) ? marker : null;
/// <summary>
/// Set transform mode of an existing <see cref="ARMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker to be transformed.</param>
/// <param name="transformMode">The <see cref="TransformMode"/> to be applied.</param>
public void SetTransformMode(TrackableId trackableId, TransformMode transformMode)
{
if (enabled && subsystem != null)
{
subsystem.SetTransformMode(trackableId, transformMode);
}
}
/// <summary>
/// Get raw data for an existing <see cref="ARMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker.</param>
public NativeArray<byte> GetRawData(TrackableId trackableId, Allocator allocator)
{
if (enabled && subsystem != null)
{
return subsystem.GetRawData(trackableId, allocator);
}
return new NativeArray<byte>();
}
/// <summary>
/// Get decoded string for an existing <see cref="ARMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker.</param>
public string GetDecodedString(TrackableId trackableId)
{
if (enabled && subsystem != null)
{
return subsystem.GetDecodedString(trackableId);
}
return null;
}
/// <summary>
/// Get QR code properties for an existing <see cref="XRMarker"/> of type <see cref="ARMarkerType.QRCode"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the QRCode marker.</param>
public QRCodeProperties GetQRCodeProperties(TrackableId trackableId)
{
if (enabled && subsystem != null)
{
return subsystem.GetQRCodeProperties(trackableId);
}
return new QRCodeProperties();
}
/// <summary>
/// Get the Prefab which will be instantiated for each <see cref="ARMarker"/>. Can be `null`.
/// </summary>
/// <returns>The Prefab which will be instantiated for each <see cref="ARMarker"/>.</returns>
protected override GameObject GetPrefab() => markerPrefab;
/// <summary>
/// Invoked when the base class detects trackable changes.
/// </summary>
/// <param name="added">The list of added <see cref="ARMarker"/>s.</param>
/// <param name="updated">The list of updated <see cref="ARMarker"/>s.</param>
/// <param name="removed">The list of removed <see cref="ARMarker"/>s.</param>
protected override void OnTrackablesChanged(
List<ARMarker> added,
List<ARMarker> updated,
List<ARMarker> removed)
{
if (markersChanged != null)
{
using (new ScopedProfiler("OnMarkersChanged"))
markersChanged(
new ARMarkersChangedEventArgs(
added,
updated,
removed));
}
}
protected override void Update()
{
base.Update();
if (enabled && subsystem != null)
{
Array.Sort(enabledMarkerTypes);
if (!enabledMarkerTypes.SequenceEqual(subsystem.EnabledMarkerTypes))
{
subsystem.EnabledMarkerTypes = enabledMarkerTypes;
}
if (defaultTransformMode != subsystem.DefaultTransformMode)
{
subsystem.DefaultTransformMode = defaultTransformMode;
}
}
}
protected override void OnEnable()
{
base.OnEnable();
// Replicating behavior in ARFoundation to initialize singleton instance
m_instance = this;
}
/// <summary>
/// The name to be used for the <c>GameObject</c> whenever a new marker object is created from <see cref="markerPrefab"/>.
/// </summary>
protected override string gameObjectName => "ARMarker";
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkerManager.cs.meta Normal file
View File

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

39
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkerScale.cs Normal file
View File

@ -0,0 +1,39 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Monobehavior to help scale detected markers.
/// </summary>
[RequireComponent(typeof(ARMarker))]
public class ARMarkerScale : MonoBehaviour
{
private ARMarker m_arMarker;
/// <summary>
/// Transform containing marker contents that needs to be scaled.
/// </summary>
[Tooltip("Transform containing marker contents that needs to be scaled.")]
public Transform markerScaleTransform;
private void OnEnable()
{
m_arMarker = GetComponent<ARMarker>();
if (markerScaleTransform == null)
{
markerScaleTransform = gameObject.transform;
}
}
private void Update()
{
// Scale the marker contents based on the computed scale factor.
float scaleFactor = (float)Math.Sqrt(m_arMarker.size.x * m_arMarker.size.y);
markerScaleTransform.transform.localScale = new Vector3(scaleFactor, scaleFactor, scaleFactor);
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkerScale.cs.meta Normal file
View File

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

59
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkersChangedEventArgs.cs Normal file
View File

@ -0,0 +1,59 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System.Collections.Generic;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Event arguments for the <see cref="ARMarkerManager.markersChanged"/> event.
/// Following design pattern set by <see cref="UnityEngine.XR.ARFoundation.ARPlanesChangedEventArgs"/>
/// </summary>
public struct ARMarkersChangedEventArgs
{
/// <summary>
/// The list of <see cref="ARMarker"/>s added since the last event.
/// </summary>
public IReadOnlyList<ARMarker> added { get; }
/// <summary>
/// The list of <see cref="ARMarker"/>s udpated since the last event.
/// </summary>
public IReadOnlyList<ARMarker> updated { get; }
/// <summary>
/// The list of <see cref="ARMarker"/>s removed since the last event.
/// </summary>
public IReadOnlyList<ARMarker> removed { get; }
/// <summary>
/// Default empty list of <see cref="ARMarker"/>s.
/// </summary>
private static IReadOnlyList<ARMarker> empty { get; } = new ARMarker[0];
/// <summary>
/// Constructs an <see cref="ARMarkersChangedEventArgs"/>.
/// </summary>
/// <param name="added">The list of <see cref="ARMarker"/>s added since the last event.</param>
/// <param name="updated">The list of <see cref="ARMarker"/>s updated since the last event.</param>
/// <param name="removed">The list of <see cref="ARMarker"/>s removed since the last event.</param>
internal ARMarkersChangedEventArgs(
IReadOnlyList<ARMarker> added,
IReadOnlyList<ARMarker> updated,
IReadOnlyList<ARMarker> removed)
{
this.added = (added != null) ? added : empty;
this.updated = (updated != null) ? updated : empty;
this.removed = (removed != null) ? removed : empty;
}
/// <summary>
/// Generates a string representation of this <see cref="ARMarkersChangedEventArgs"/>.
/// </summary>
/// <returns>A string representation of this <see cref="ARMarkersChangedEventArgs"/>.</returns>
public override string ToString()
{
return string.Format("Added: {0}, Updated: {1}, Removed: {2}", added.Count, updated.Count, removed.Count);
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/ARMarkersChangedEventArgs.cs.meta Normal file
View File

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

119
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarker.cs Normal file
View File

@ -0,0 +1,119 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.XR.ARSubsystems;
using Pose = UnityEngine.Pose;
namespace Microsoft.MixedReality.OpenXR.ARSubsystems
{
/// <summary>
/// The session-relative data associated with a marker.
/// Following design pattern set by <see cref="UnityEngine.XR.ARSubsystems.BoundedPlane"/>
/// </summary>
/// <seealso cref="XRMarkerSubsystem"/>
[StructLayout(LayoutKind.Sequential)]
public struct XRMarker : ITrackable
{
private static readonly XRMarker s_Default = new XRMarker(
TrackableId.invalidId,
Pose.identity,
TrackingState.None,
Vector2.zero,
Vector2.zero,
0.0f,
TransformMode.MostStable,
ARMarkerType.QRCode,
IntPtr.Zero);
/// <summary>
/// Gets a default-initialized <see cref="XRMarker"/>. This can be
/// different from the zero-initialized version, e.g., the <see cref="pose"/>
/// is <c>Pose.identity</c> instead of zero-initialized.
/// </summary>
internal static XRMarker defaultValue => s_Default;
/// <summary>
/// Constructs a new <see cref="XRMarker"/>. This is just a data container
/// for a marker's session relative data. These are typically created by
/// <see cref="XRMarkerSubsystem.GetChanges(Unity.Collections.Allocator)"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> associated with the marker.</param>
/// <param name="pose">The <c>Pose</c> associated with the marker.</param>
/// <param name="trackingState">The <see cref="TrackingState"/> associated with the marker.</param>
/// <param name="center">The center of the marker, in marker space (relative to <paramref name="pose"/>).</param>
/// <param name="size">The dimensions associated with the marker.</param>
/// <param name="lastSeenTime">The time when the marker was last seen.</param>
/// <param name="markerType">The type of the marker. Currently only markers of type QRCode are supported.</param>
/// <param name="nativePtr">The native pointer associated with the marker.</param>
internal XRMarker(
TrackableId trackableId,
Pose pose,
TrackingState trackingState,
Vector2 center,
Vector2 size,
float lastSeenTime,
TransformMode transformMode,
ARMarkerType markerType,
IntPtr nativePtr)
{
this.trackableId = trackableId;
this.pose = pose;
this.trackingState = trackingState;
this.center = center;
this.size = size;
this.lastSeenTime = lastSeenTime;
this.transformMode = transformMode;
this.markerType = markerType;
this.nativePtr = nativePtr;
}
/// <summary>
/// The <see cref="TrackableId"/> associated with this marker.
/// </summary>
public TrackableId trackableId { get; }
/// <summary>
/// The <c>Pose</c>, in session space, of the marker.
/// </summary>
public Pose pose { get; internal set; }
/// <summary>
/// The <see cref="TrackingState"/> of the marker.
/// </summary>
public TrackingState trackingState { get; internal set; }
/// <summary>
/// The center of the marker in marker space (relative to its <see cref="pose"/>).
/// </summary>
public Vector2 center { get; internal set; }
/// <summary>
/// The size (dimensions) of the marker in meters.
/// </summary>
public Vector2 size { get; internal set; }
/// <summary>
/// The time the marker was last seen.
/// </summary>
public float lastSeenTime { get; internal set; }
/// <summary>
/// The type of transform on the marker.
/// </summary>
public TransformMode transformMode { get; internal set; }
/// <summary>
/// The type of the marker. Currently we only support markers of type QRCode.
/// </summary>
public ARMarkerType markerType { get; }
/// <summary>
/// A native pointer associated with this marker.
/// The data pointer to by this pointer is implementation defined.
/// </summary>
public IntPtr nativePtr { get; }
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarker.cs.meta Normal file
View File

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

156
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarkerSubsystem.cs Normal file
View File

@ -0,0 +1,156 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using Unity.Collections;
using UnityEngine.SubsystemsImplementation;
using UnityEngine.XR.ARSubsystems;
namespace Microsoft.MixedReality.OpenXR.ARSubsystems
{
/// <summary>
/// Base class for marker subsystems.
/// </summary>
/// <remarks>
/// This subsystem surfaces information regarding the detection of markers such as QRCodes in the physical environment.
/// </remarks>
public class XRMarkerSubsystem
: TrackingSubsystem<XRMarker, XRMarkerSubsystem, XRMarkerSubsystemDescriptor, XRMarkerSubsystem.Provider>
{
public XRMarkerSubsystem() { }
/// <summary>
/// Get or set the list of marker types <see cref="ARMarkerType"/> that will be detected.
/// </summary>
internal ARMarkerType[] EnabledMarkerTypes
{
get => provider.EnabledMarkerTypes;
set => provider.EnabledMarkerTypes = value;
}
/// <summary>
/// Default <see cref="TransformMode"/> for newly detected markers.
/// </summary>
public TransformMode DefaultTransformMode
{
get => provider.DefaultTransformMode;
set => provider.DefaultTransformMode = value;
}
/// <summary>
/// Get the changes to markers (added, updated, and removed) since the last call to <see cref="GetChanges(Allocator)"/>.
/// </summary>
/// <param name="allocator">An <c>Allocator</c> to use when allocating the returned <c>NativeArray</c>s.</param>
/// <returns>
/// <see cref="TrackableChanges{T}"/> that describes the markers that have been added, updated, and removed
/// since the last call to <see cref="GetChanges(Allocator)"/>. The caller owns the memory allocated with <c>Allocator</c>.
/// </returns>
public override TrackableChanges<XRMarker> GetChanges(Allocator allocator)
{
var changes = provider.GetChanges(XRMarker.defaultValue, allocator);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
m_ValidationUtility.ValidateAndDisposeIfThrown(changes);
#endif
return changes;
}
/// <summary>
/// Set transform mode of an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker to be transformed.</param>
/// <param name="transformMode">The <see cref="TransformMode"/> to be applied.</param>
public void SetTransformMode(TrackableId trackableId, TransformMode transformMode)
{
provider.SetTransformMode(trackableId, transformMode);
}
/// <summary>
/// Get raw data for an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker.</param>
public NativeArray<byte> GetRawData(TrackableId trackableId, Allocator allocator)
{
return provider.GetRawData(trackableId, allocator);
}
/// <summary>
/// Get decoded string for an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker to be transformed.</param>
public string GetDecodedString(TrackableId trackableId)
{
return provider.GetDecodedString(trackableId);
}
/// <summary>
/// Get QR code properties for an existing <see cref="XRMarker"/> of type <see cref="ARMarkerType.QRCode"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the QRCode marker.</param>
public QRCodeProperties GetQRCodeProperties(TrackableId trackableId)
{
return provider.GetQRCodeProperties(trackableId);
}
/// <summary>
/// The API that derived classes must implement.
/// </summary>
public abstract class Provider : SubsystemProvider<XRMarkerSubsystem>
{
/// <summary>
/// Get the changes to markers (added, updated, and removed) since the last call to
/// <see cref="GetChanges(XRMarker,Allocator)"/>.
/// </summary>
/// <param name="defaultMarker">
/// The default marker. This should be used to initialize the returned <c>NativeArray</c>s for backwards compatibility.
/// See <see cref="TrackableChanges{T}.TrackableChanges(void*, int, void*, int, void*, int, T, int, Allocator)"/>.
/// </param>
/// <param name="allocator">An <c>Allocator</c> to use when allocating the returned <c>NativeArray</c>s.</param>
/// <returns>
/// <see cref="TrackableChanges{T}"/> describing the markers that have been added, updated, and removed
/// since the last call to <see cref="GetChanges(XRMarker,Allocator)"/>. The changes should be allocated using
/// <paramref name="allocator"/>.
/// </returns>
public abstract TrackableChanges<XRMarker> GetChanges(XRMarker defaultMarker, Allocator allocator);
/// <summary>
/// Set transform mode of an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker to be transformed.</param>
/// <param name="transformMode">The <see cref="TransformMode"/> to be applied.</param>
public abstract void SetTransformMode(TrackableId trackableId, TransformMode transformMode);
/// <summary>
/// Get raw data for an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker.</param>
public abstract NativeArray<byte> GetRawData(TrackableId trackableId, Allocator allocator);
/// <summary>
/// Get decoded string for an existing <see cref="XRMarker"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the marker.</param>
public abstract string GetDecodedString(TrackableId trackableId);
/// <summary>
/// Get QR code properties for an existing <see cref="XRMarker"/> of type <see cref="ARMarkerType.QRCode"/>.
/// </summary>
/// <param name="trackableId">The <see cref="TrackableId"/> of the QRCode marker.</param>
public abstract QRCodeProperties GetQRCodeProperties(TrackableId trackableId);
/// <summary>
/// Get or set the list of marker types <see cref="ARMarkerType"/> that will be detected.
/// </summary>
internal abstract ARMarkerType[] EnabledMarkerTypes { get; set; }
/// <summary>
/// Default <see cref="TransformMode"/> for newly detected markers.
/// </summary>
internal abstract TransformMode DefaultTransformMode { get; set; }
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
private ValidationUtility<XRMarker> m_ValidationUtility =
new ValidationUtility<XRMarker>();
#endif
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarkerSubsystem.cs.meta Normal file
View File

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

53
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarkerSubsystemDescriptor.cs Normal file
View File

@ -0,0 +1,53 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using UnityEngine.SubsystemsImplementation;
namespace Microsoft.MixedReality.OpenXR.ARSubsystems
{
public class XRMarkerSubsystemDescriptor :
SubsystemDescriptorWithProvider<XRMarkerSubsystem, XRMarkerSubsystem.Provider>
{
internal struct Cinfo
{
/// <summary>
/// The string identifier for a specific implementation.
/// </summary>
internal string id { get; set; }
/// <summary>
/// Specifies the provider implementation type to use for instantiation.
/// </summary>
/// <value>
/// The provider implementation type to use for instantiation.
/// </value>
internal Type providerType { get; set; }
/// <summary>
/// Specifies the <c>XRMarkerSubsystem</c>-derived type that forwards casted calls to its provider.
/// </summary>
/// <value>
/// The type of the subsystem to use for instantiation. If null, <c>XRMarkerSubsystem</c> will be instantiated.
/// </value>
internal Type subsystemTypeOverride { get; set; }
}
/// <summary>
/// Creates a new subsystem descriptor and registers it with the <c>SubsystemManager</c>.
/// </summary>
/// <param name="cinfo">Construction info for the descriptor.</param>
internal static void Create(Cinfo cinfo)
{
var descriptor = new XRMarkerSubsystemDescriptor(cinfo);
SubsystemDescriptorStore.RegisterDescriptor(descriptor);
}
private XRMarkerSubsystemDescriptor(Cinfo cinfo)
{
id = cinfo.id;
providerType = cinfo.providerType;
subsystemTypeOverride = cinfo.subsystemTypeOverride;
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ARMarker/XRMarkerSubsystemDescriptor.cs.meta Normal file
View File

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

185
com.microsoft.mixedreality.openxr/Runtime/API/AnchorConverter.cs Normal file
View File

@ -0,0 +1,185 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using TrackableId = UnityEngine.XR.ARSubsystems.TrackableId;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Provides helper functions to convert an Unity Anchor object to underlying OpenXR anchor handle or SpatialAnchor COM object.
/// </summary>
public static class AnchorConverter
{
private static MixedRealityFeaturePlugin Feature => OpenXRFeaturePlugin<MixedRealityFeaturePlugin>.Feature;
/// <summary>
/// Get the OpenXR handle of the given nativePtr from ARAnchor or XRAnchor object if available, or return 0.
/// </summary>
/// <param name="nativePtr">The nativePtr obtained from either XRAnchor.nativePtr or ARAnchor.nativePtr.</param>
/// <returns>XrAnchorMSFT handle that represents the underlying OpenXR anchor of given nativePtr, or 0 when such associated handle cannot be found.</returns>
public static ulong ToOpenXRHandle(IntPtr nativePtr)
{
if (nativePtr == null)
return 0;
NativeAnchorData data = Marshal.PtrToStructure<NativeAnchorData>(nativePtr);
if (data.version == 1)
{
return data.anchorHandle;
}
return 0;
}
/// <summary>
/// Create a new ARAnchor from the given OpenXR XRSpatialAnchorMSFT handle.
/// </summary>
/// <param name="openxrAnchorHandle">A valid OpenXR XRSpatialAnchorMSFT handle.</param>
/// <returns>Returns the trackable id representing the Unity anchor or <see cref="TrackableId.invalidId"/> if the conversion was unsuccessful.</returns>
/// <remarks>The newly created TrackableId will not be added to <see cref="UnityEngine.XR.ARFoundation.ARTrackableManager{TSubsystem, TSubsystemDescriptor, TProvider, TSessionRelativeData, TTrackable}.trackables"/> collection until the next frame's Update.
/// The app should listen to the <see cref="UnityEngine.XR.ARFoundation.ARAnchorManager.anchorsChanged"/> event for the added ARAnchor object with the returned trackableId.</remarks>
public static TrackableId CreateFromOpenXRHandle(ulong openxrAnchorHandle)
{
if (Feature.IsValidAndEnabled() && openxrAnchorHandle != 0)
{
Guid guid = NativeLib.TryCreateARAnchorFromOpenXRHandle(openxrAnchorHandle);
return FeatureUtils.ToTrackableId(guid);
}
return TrackableId.invalidId;
}
/// <summary>
/// Get a COM wrapper object of Windows.Perception.Spatial.SpatialAnchor from the given ARAnchor's nativePtr.
/// </summary>
/// <param name="nativePtr">The nativePtr obtained from either XRAnchor.nativePtr or ARAnchor.nativePtr.</param>
/// <returns>The COM wrapper object of Windows.Perception.Spatial.SpatialAnchor, or null when the conversion failed.</returns>
public static object ToPerceptionSpatialAnchor(IntPtr nativePtr)
{
if (Feature.IsValidAndEnabled() && nativePtr != IntPtr.Zero)
{
IntPtr unknown = NativeLib.TryAcquirePerceptionSpatialAnchor(ToOpenXRHandle(nativePtr));
if (unknown != IntPtr.Zero)
{
object result = Marshal.GetObjectForIUnknown(unknown);
Marshal.Release(unknown); // Balance the ref count because "feature.TryAcquire" increment it on return.
return result;
}
}
return null;
}
/// <summary>
/// Get a COM wrapper object of Windows.Perception.Spatial.SpatialAnchor from the given TrackableId.
/// If failed, the function returns nullptr.
/// </summary>
/// <param name="trackableId">An existing XRAnchor or ARAnchor's ID.</param>
/// <returns>The COM wrapper object of Windows.Perception.Spatial.SpatialAnchor, or null when the conversion failed.</returns>
public static object ToPerceptionSpatialAnchor(TrackableId trackableId)
{
if (Feature.IsValidAndEnabled() && trackableId != TrackableId.invalidId)
{
IntPtr unknown = NativeLib.TryAcquirePerceptionSpatialAnchor(FeatureUtils.ToGuid(trackableId));
if (unknown != IntPtr.Zero)
{
object result = Marshal.GetObjectForIUnknown(unknown);
Marshal.Release(unknown); // Balance the ref count because "feature.TryAcquire" increment it on return.
return result;
}
}
return null;
}
/// <summary>
/// Creating a new ARAnchor from the given Windows.Perception.Spatial.SpatialAnchor.
/// If failed, the function returns TrackableId.invalidId.
/// Creates an OpenXR anchor from a Windows.Perception.Spatial.SpatialAnchor and reports it to Unity.
/// </summary>
/// <param name="spatialAnchor">Must be a Windows.Perception.Spatial.SpatialAnchor.</param>
/// <returns>Returns the trackable id representing the Unity anchor or <see cref="TrackableId.invalidId"/> if the conversion was unsuccessful.</returns>
/// <remarks>The newly created TrackableId will not be added to <see cref="UnityEngine.XR.ARFoundation.ARTrackableManager{TSubsystem, TSubsystemDescriptor, TProvider, TSessionRelativeData, TTrackable}.trackables"/> collection until the next frame's Update.
/// The app should listen to the <see cref="UnityEngine.XR.ARFoundation.ARAnchorManager.anchorsChanged"/> event for the added ARAnchor object with the returned trackableId.</remarks>
[Obsolete("Obsolete and will be removed in future releases. Use the `CreateFromPerceptionSpatialAnchor` function instead.")]
public static TrackableId FromPerceptionSpatialAnchor(object spatialAnchor)
{
return CreateFromPerceptionSpatialAnchor(spatialAnchor);
}
/// <summary>
/// Creating a new ARAnchor from the given Windows.Perception.Spatial.SpatialAnchor.
/// If failed, the function returns TrackableId.invalidId.
/// Creates an OpenXR anchor from a Windows.Perception.Spatial.SpatialAnchor and reports it to Unity.
/// </summary>
/// <param name="spatialAnchor">Must be a Windows.Perception.Spatial.SpatialAnchor.</param>
/// <returns>Returns the trackable id representing the Unity anchor or <see cref="TrackableId.invalidId"/> if the conversion was unsuccessful.</returns>
/// <remarks>The newly created TrackableId will not be added to <see cref="UnityEngine.XR.ARFoundation.ARTrackableManager{TSubsystem, TSubsystemDescriptor, TProvider, TSessionRelativeData, TTrackable}.trackables"/> collection until the next frame's Update.
/// The app should listen to the <see cref="UnityEngine.XR.ARFoundation.ARAnchorManager.anchorsChanged"/> event for the added ARAnchor object with the returned trackableId.</remarks>
public static TrackableId CreateFromPerceptionSpatialAnchor(object spatialAnchor)
{
if (Feature.IsValidAndEnabled() && spatialAnchor != null)
{
Guid guid = NativeLib.TryCreateARAnchorFromPerceptionAnchor(spatialAnchor);
return FeatureUtils.ToTrackableId(guid);
}
return TrackableId.invalidId;
}
/// <summary>
/// Replaces the underlying platform anchor for an existing XRAnchor/ARAnchor represented by the
/// given TrackableId, so the Unity anchor will instead be located by the given SpatialAnchor.
/// </summary>
/// <remarks>Use this function instead of <see cref="FromPerceptionSpatialAnchor"/> to avoid creating new ARAnchor on every new platform anchor.</remarks>
/// <param name="spatialAnchor">Must be a Windows.Perception.Spatial.SpatialAnchor.</param>
/// <param name="existingId">An id representing an existing XRAnchor/ARAnchor.</param>
/// <returns>Returns the trackable id representing the Unity anchor or <see cref="TrackableId.invalidId"/> if the conversion was unsuccessful.</returns>
public static TrackableId ReplaceSpatialAnchor(object spatialAnchor, TrackableId existingId)
{
if (Feature.IsValidAndEnabled() && spatialAnchor != null)
{
Guid guid = NativeLib.TryAcquireAndReplaceXrSpatialAnchor(spatialAnchor, FeatureUtils.ToGuid(existingId));
return FeatureUtils.ToTrackableId(guid);
}
return TrackableId.invalidId;
}
}
namespace ARSubsystems
{
/// <summary>
/// Provides extension function to convert an XRAnchor object to underlying OpenXR anchor handle.
/// </summary>
[System.Obsolete("Obsolete and will be removed in future releases. Use AnchorConverter.ToOpenXRHandle() function instead.", true)]
public static class XRAnchorExtensions
{
/// <summary>
/// Get the native OpenXR handle of the given XRAnchor object if available, or return 0.
/// </summary>
/// <param name="anchor">A valid <see cref="UnityEngine.XR.ARSubsystems.XRAnchor"/> object.</param>
/// <returns>XrAnchorMSFT handle that represents the underlying OpenXR anchor, or 0 when such associated handle cannot be found.</returns>
public static ulong GetOpenXRHandle(this UnityEngine.XR.ARSubsystems.XRAnchor anchor)
{
return anchor == null ? 0 : AnchorConverter.ToOpenXRHandle(anchor.nativePtr);
}
}
}
namespace ARFoundation
{
/// <summary>
/// Provides extension function to convert an ARAnchor object to underlying OpenXR anchor handle.
/// </summary>
[System.Obsolete("Obsolete and will be removed in future releases. Use AnchorConverter.ToOpenXRHandle() function instead.", true)]
public static class ARAnchorExtensions
{
/// <summary>
/// Get the native OpenXR handle of the given ARAnchor object if available, or return 0.
/// </summary>
/// <param name="anchor">A valid <see cref="UnityEngine.XR.ARFoundation.ARAnchor"/> object.</param>
/// <returns>XrAnchorMSFT handle that represents the underlying OpenXR anchor, or 0 when such associated handle cannot be found.</returns>
public static ulong GetOpenXRHandle(this UnityEngine.XR.ARFoundation.ARAnchor anchor)
{
return anchor == null ? 0 : AnchorConverter.ToOpenXRHandle(anchor.nativePtr);
}
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/AnchorConverter.cs.meta Normal file
View File

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

842
com.microsoft.mixedreality.openxr/Runtime/API/AppRemoting.cs Normal file
View File

@ -0,0 +1,842 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using Unity.Collections;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR.Remoting
{
/// <summary>
/// Provides information and configuration for creating a Holographic Remoting remote app.
/// </summary>
/// <remarks>
/// Please note that client/server and player/remote are orthogonal concepts in remoting.
/// Holographic Remoting remote app can act as either a
/// Server - when listening to incoming connection from a Holographic Remoting player app (Client)
/// (or)
/// Client - when connecting to Holographic Remoting player app (Server) that is listening to incoming connections.
/// For more details, please reference the <see href="https://docs.microsoft.com/windows/mixed-reality/develop/native/holographic-remoting-terminology">Holographic Remoting Terminology</see>.
/// </remarks>
public static class AppRemoting
{
/// <summary>
/// Starts connecting with given Holographic Remoting remote app (Client) configuration and initializes XR.
/// </summary>
/// <remarks>
/// The remote app (Client) will try and connect to remote player (Server) listening for incoming connections,
/// and after a successful connection, XR experience starts. If the connection fails for any reason, try to connect by calling the coroutine again.
/// This method must be run as a coroutine itself, as initializing XR has to happen in a coroutine.
/// </remarks>
/// <param name="configuration">The set of parameters to use for remoting.</param>
[Obsolete("This method is obsolete. Use the ConnectToPlayer() method instead.", false)]
public static System.Collections.IEnumerator Connect(RemotingConfiguration configuration)
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The Connect() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
yield break;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The Connect() function is not supported in PlayMode Remoting.");
yield break;
}
yield return subsystem.ConnectLegacy(configuration);
}
/// <summary>
/// Starts connecting with given Holographic Remoting remote app (Client) configuration and initializes XR.
/// </summary>
/// <remarks>
/// This remote app (Client) will try and connect to a remote player (Server) listening for incoming connections.
/// After a successful connection, the XR experience will be started. Apps can use <see cref="ConnectionState"/> to
/// monitor the ongoing connection and use <see cref="ReadyToStart"/> to drive future connections.
/// This method will return quickly and is safe for use in UI threads.
/// </remarks>
/// <param name="connectConfiguration">The set of parameters to use for remoting.</param>
/// <remarks>
/// During this connection, for the duration when <see cref="IsReadyToStart"/> is false,
/// calling <see cref="StartConnectingToPlayer"/> will be a no-op and an error message will appear in the logs.
/// If the app wants to retry the connection, it should wait for "IsReadyToStart" to changed to true,
/// or monitor the "ReadyToStart" event.
/// </remarks>
public static void StartConnectingToPlayer(RemotingConnectConfiguration connectConfiguration)
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The StartConnectingToPlayer() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
return;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The StartConnectingToPlayer() function is not supported in PlayMode Remoting.");
return;
}
subsystem.StartConnecting(connectConfiguration);
}
/// <summary>
/// Starts listening with given Holographic Remoting remote app (Server) configuration and initializes XR.
/// </summary>
/// <remarks>
/// The remote app (Server) will be waiting for remote player (Client) to connect, and after a successful connection, XR experience starts.
/// If the connection fails for any reason, it will retry listening for incoming connection until some other method is called.
/// This method must be run as a coroutine itself, as initializing XR has to happen in a coroutine.
/// </remarks>
/// <param name="listenConfiguration">The set of parameters to use for remoting.</param>
/// <param name="onRemotingListenCompleted"> Action callback to signal listen complete. A new Connect or Listen coroutine can safely be started after this callback.</param>
/// <remarks>
/// During a Listen coroutine, if the remote app calls <see cref="Listen"/> or <see cref="Connect"/> function,
/// the second call will fail, because there can only be a single outstanding remoting connection. The Listen coroutine will wait indefinitely for new connections
/// until the remote app calls <see cref="Disconnect"/> function to stop listening. During this coroutine, there could be multiple remoting connections
/// and the <see cref="ConnectionState"/> may change multiple times. If the remote app wants to know the completion of above listening session,
/// it can use the `onRemotingListenCompleted` callback here. After the callback, the Listen coroutine will complete, and the application can safely call the `Connect` or `Listen` functions again.
/// </remarks>
[Obsolete("This method is obsolete. Use the StartListeningForPlayer() instead.", false)]
public static System.Collections.IEnumerator Listen(RemotingListenConfiguration listenConfiguration, Action onRemotingListenCompleted = null)
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The Listen() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
if (onRemotingListenCompleted != null)
{
onRemotingListenCompleted.Invoke();
}
yield break;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The Listen() function is not supported in PlayMode Remoting.");
if (onRemotingListenCompleted != null)
{
onRemotingListenCompleted.Invoke();
}
yield break;
}
yield return subsystem.ListenLegacy(listenConfiguration, ListenMode.LegacyListen, onRemotingListenCompleted);
}
/// <summary>
/// Starts listening with given Holographic Remoting remote app (Server) configuration and initializes XR.
/// </summary>
/// <remarks>
/// The remote app (Server) will be waiting for remote player (Client) to connect, and after a successful connection, XR experience starts.
/// This method will return quickly and is safe for use in UI threads. Apps can use <see cref="ConnectionState"/> to monitor the ongoing connection.
/// If the connection fails for any reason, it will retry listening for incoming connection until <see cref="StopListening"/> or <see cref="Disconnect"/> is called.
/// </remarks>
/// <param name="listenConfiguration">The set of parameters to use for remoting.</param>
/// <remarks>
/// During this connection, for the duration when <see cref="IsReadyToStart"/> is false,
/// calling <see cref="StartListeningForPlayer"/> will be a no-op and an error message will appear in the logs.
/// If the app wants to retry the connection, it should wait for "IsReadyToStart" to changed to true,
/// or monitor the "ReadyToStart" event.
/// </remarks>
public static void StartListeningForPlayer(RemotingListenConfiguration listenConfiguration)
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The StartListeningForPlayer() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
return;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The StartListeningForPlayer() function is not supported in PlayMode Remoting.");
return;
}
subsystem.StartListening(listenConfiguration, ListenMode.Listen, null);
}
/// <summary>
/// Disconnects the remote app (Client/Server) from the remote player (Client/Server) and stops the active XR session.
/// </summary>
/// <remarks>
/// Disconnects network connection between remote app and remote player, stops <see cref="ConnectToPlayer"/>, <see cref="Connect"/> and <see cref="Listen"/> coroutines.
/// It does not stop <see cref="StartListeningForPlayer"/> coroutine, use <see cref="StopListening"/> instead. `Disconnect` is not equivalent to the completion of `ConnectToPlayer` coroutine,
/// please use a wrapper coroutine, as explained in <see cref="ConnectToPlayer"/> to identify completion.
/// </remarks>
public static void Disconnect()
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The Disconnect() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
return;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The Disconnect() function is not supported in PlayMode Remoting.");
return;
}
subsystem.Disconnect();
}
/// <summary>
/// Stops listening on the remote app (Server) for incoming connections from the remote player (Client) and stops the active XR session.
/// </summary>
/// <remarks>
/// Disconnects any outstanding Listen session and exits <see cref="StartListeningForPlayer"/> coroutine, throws an error if used with <see cref="Listen"/> coroutine.
/// `StopListening` is not equivalent to the completion of `StartListeningForPlayer` coroutine, please use a wrapper coroutine as explained in <see cref="StartListeningForPlayer"/>
/// to identify completion.
/// </remarks>
public static void StopListening()
{
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled())
{
Debug.LogWarning($"The StopListening() function is not supported without enabling the \"Holographic Remoting remote app\" feature in OpenXR project settings.");
return;
}
if (subsystem.InPlayModeRemoting())
{
Debug.LogWarning($"The StopListening() function is not supported in PlayMode Remoting.");
return;
}
subsystem.StopListening();
}
/// <summary>
/// Indicates whether a remoting connection is ready to be started using
/// <see cref="StartConnectingToPlayer"/> or <see cref="StartListeningForPlayer"/>.
/// </summary>
/// <remarks>
/// This functionality needs the "Holographic Remoting remote app" feature in OpenXR project settings to be enabled and returns false otherwise.
/// This functionality always returns false in Holographic PlayMode Remoting.
/// </remarks>
public static bool IsReadyToStart
{
get => AppRemotingSubsystem.GetCurrent().IsReadyToStart();
}
/// <summary>
/// Provides information on the current remoting session, if one exists.
/// </summary>
/// <param name="connectionState">The current connection state of the remote session.</param>
/// <param name="disconnectReason">If the connection state is disconnected, this helps explain why.</param>
/// <returns>Whether the information was successfully retrieved.</returns>
/// <remarks>
/// This functionality needs the "Holographic Remoting remote app" feature in OpenXR project settings to be enabled and returns false otherwise.
/// This functionality always returns false in Holographic PlayMode Remoting.
/// </remarks>
public static bool TryGetConnectionState(out ConnectionState connectionState, out DisconnectReason disconnectReason)
{
connectionState = ConnectionState.Disconnected;
disconnectReason = DisconnectReason.None;
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled() || subsystem.InPlayModeRemoting())
{
return false;
}
return subsystem.TryGetConnectionState(out connectionState, out disconnectReason);
}
/// <summary>
/// To locate the `XR_REMOTING_REFERENCE_SPACE_TYPE_USER_MSFT` reference space in Unity's scene origin space in the remote app. For more details, reference the
/// <see href="https://docs.microsoft.com/windows/mixed-reality/develop/native/holographic-remoting-coordinate-system-synchronization-openxr">Coordinate System Synchronization with Holographic Remoting</see>.
/// </summary>
/// <param name="frameTime">Specify the <see cref="FrameTime"/> to locate the user reference space.</param>
/// <param name="pose">Output the pose of the user reference space in the Unity's scene origin space.</param>
/// <returns>Returns true when the user reference space is tracking and output pose is valid to be used.
/// Returns false when the user reference space lost tracking or it's not properly set up.</returns>
/// <remarks>
/// This functionality needs the "Holographic Remoting remote app" feature in OpenXR project settings to be enabled and returns false otherwise.
/// This functionality always returns false in Holographic PlayMode Remoting.
/// </remarks>
public static bool TryLocateUserReferenceSpace(FrameTime frameTime, out Pose pose)
{
pose = Pose.identity;
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled() || subsystem.InPlayModeRemoting())
{
return false;
}
return subsystem.TryLocateUserReferenceSpace(frameTime, out pose);
}
/// <summary>
/// Convert the time from a player app QPC time to the synchronized remote app QPC time.
/// </summary>
/// <param name="playerPerformanceCount">The performance count obtained in the player app using QueryPerformanceCounter.</param>
/// <param name="remotePerformanceCount">Output the synchronized performance count as if it is using QueryPerformanceCounter in the remote app at the same time.
/// The output will be 0, indicating invalid time, if the function returns false.</param>
/// <returns>Returns true when the time is successfully converted.
/// Returns false when the time synchronization between remote and player app is not yet established.
/// </returns>
/// <remarks>
/// This functionality needs the "Holographic Remoting remote app" feature in OpenXR project settings to be enabled and returns false otherwise.
/// This functionality always returns false in Holographic PlayMode Remoting.
/// </remarks>
public static bool TryConvertToRemoteTime(long playerPerformanceCount, out long remotePerformanceCount)
{
remotePerformanceCount = 0; // default to invalid timestamp
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled() || subsystem.InPlayModeRemoting())
{
return false;
}
return subsystem.TryConvertToRemoteTime(playerPerformanceCount, out remotePerformanceCount);
}
/// <summary>
/// Convert the time from a remote app QPC time to the synchronized player app QPC time.
/// </summary>
/// <param name="remotePerformanceCount">The performance count obtained in the remote app using QueryPerformanceCounter.</param>
/// <param name="playerPerformanceCount">Output the synchronized performance count as if it is using QueryPerformanceCounter in the player app at the same time.
/// The output will be 0, indicating invalid time, if the function returns false.</param>
/// <returns>Returns true when the time is successfully converted.
/// Returns false when the time synchronization between remote and player app is not yet established.
/// </returns>
/// <remarks>
/// This functionality needs the "Holographic Remoting remote app" feature in OpenXR project settings to be enabled and returns false otherwise.
/// This functionality always returns false in Holographic PlayMode Remoting.
/// </remarks>
public static bool TryConvertToPlayerTime(long remotePerformanceCount, out long playerPerformanceCount)
{
playerPerformanceCount = 0; // default to invalid timestamp
AppRemotingSubsystem subsystem = AppRemotingSubsystem.GetCurrent();
if (!subsystem.IsAppRemotingEnabled() || subsystem.InPlayModeRemoting())
{
return false;
}
return subsystem.TryConvertToPlayerTime(remotePerformanceCount, out playerPerformanceCount);
}
/// <summary>
/// Event triggered when <see cref="IsReadyToStart"/> changes from false to true.
/// </summary>
/// <remarks>
/// Typically, applications can use this event to re-enable UX allowing the user to start a new remoting connection, as this
/// event indicates previous remoting sessions have fully completed and AppRemoting is ready for a new connection to start.
/// This event will only be triggered if the "Holographic Remoting remote app" feature in OpenXR project settings is enabled and
/// is never triggered in Holographic PlayMode Remoting.
/// </remarks>
public static event ReadyToStartDelegate ReadyToStart
{
add
{
AppRemotingSubsystem.GetCurrent().ReadyToStart += value;
}
remove
{
AppRemotingSubsystem.GetCurrent().ReadyToStart -= value;
}
}
/// <summary>
/// Event triggered when the connection between remote app (Client/Server) and player is successfully established.
/// </summary>
/// <remarks>
/// This event will only be triggered if the "Holographic Remoting remote app" feature in OpenXR project settings is enabled and
/// is never triggered in Holographic PlayMode Remoting.
/// </remarks>
public static event ConnectedDelegate Connected
{
add
{
AppRemotingSubsystem.GetCurrent().Connected += value;
}
remove
{
AppRemotingSubsystem.GetCurrent().Connected -= value;
}
}
/// <summary>
/// Event triggered when the connection between remote app (Client/Server) and player is disconnecting.
/// </summary>
/// <remarks>
/// This event might be triggered several times during the `StartListeningForPlayer` coroutine.
/// This may also be triggered without a corresponding "Connected" event.
/// This event will only be triggered if the "Holographic Remoting remote app" feature in OpenXR project settings is enabled and
/// is never triggered in Holographic PlayMode Remoting.
/// </remarks>
public static event DisconnectingDelegate Disconnecting
{
add
{
AppRemotingSubsystem.GetCurrent().Disconnecting += value;
}
remove
{
AppRemotingSubsystem.GetCurrent().Disconnecting -= value;
}
}
}
/// <summary>
/// Describes the event handler that can be implemented by remote app to get notified when <see cref="IsReadyToStart"/> changes from false to true.
/// </summary>
public delegate void ReadyToStartDelegate();
/// <summary>
/// Describes the event handler that can be implemented by remote app to get notified on a <see cref="Connected"/> event.
/// </summary>
public delegate void ConnectedDelegate();
/// <summary>
/// Describes the event handler that can be implemented by remote app to get notified on a <see cref="Disconnecting"/> event.
/// </summary>
/// <param name="disconnectReason">The reason for disconnecting</param>
public delegate void DisconnectingDelegate(DisconnectReason disconnectReason);
/// <summary>
/// Describes the preferred video codec to use for the connection.
/// </summary>
public enum RemotingVideoCodec
{
/// <summary>
/// Represents HEVC video codec preferred, fall back to H264 if HEVC is not supported by all participants.
/// </summary>
Auto = 0,
/// <summary>
/// Represents HEVC video codec.
/// </summary>
H265,
/// <summary>
/// Represents H264 video codec.
/// </summary>
H264,
}
/// <summary>
/// Describes the preferred audio capture mode to use for the connection.
/// </summary>
/// <remarks>
/// "EnableAudio" parameter in <see cref="RemotingConnectConfiguration"/> or <see cref="RemotingListenConfiguration"/> has to be set to true for this selection to take effect.
/// This is only supported if the remote app runs on Windows 10 build 20348 or later.The default behavior with older Windows builds is capturing the entire system audio, regardless of the selection.
/// </remarks>
public enum RemotingAudioCaptureMode
{
/// <summary>
/// Represents capturing the whole system wide audio on the remote app's end and stream it to the player app.
/// </summary>
SystemWideCapture = 0,
/// <summary>
/// Represents capturing only the in app audio on the remote app's end and stream it to the player app.
/// </summary>
InAppCapture,
}
/// <summary>
/// Specifies the configuration for the remote app (Client) to initiate a remoting connection.
/// </summary>
[Serializable, StructLayout(LayoutKind.Sequential, Pack = 8)]
[Obsolete("This struct is obsolete. Use 'RemotingConnectConfiguration' instead.", false)]
public struct RemotingConfiguration
{
/// <summary>
/// The host name or IP address of the player running in network server mode to connect to.
/// </summary>
public string RemoteHostName;
/// <summary>
/// The port number of the server's handshake port.
/// </summary>
public ushort RemotePort;
/// <summary>
/// The max bitrate in Kbps to use for the connection.
/// </summary>
public uint MaxBitrateKbps;
/// <summary>
/// The video codec to use for the connection.
/// </summary>
public RemotingVideoCodec VideoCodec;
/// <summary>
/// Enable/disable audio remoting.
/// </summary>
public bool EnableAudio;
}
/// <summary>
/// Specifies the configuration for the remote app (Client) to initiate a remoting connection.
/// </summary>
[Serializable, StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct RemotingConnectConfiguration
{
/// <summary>
/// The host name or IP address of the player running in network server mode to connect to.
/// </summary>
public string RemoteHostName;
/// <summary>
/// The port number of the server's handshake port.
/// </summary>
public ushort RemotePort;
/// <summary>
/// The max bitrate in Kbps to use for the connection.
/// </summary>
public uint MaxBitrateKbps;
/// <summary>
/// The video codec to use for the connection.
/// </summary>
public RemotingVideoCodec VideoCodec;
/// <summary>
/// Enable/disable audio remoting.
/// </summary>
public bool EnableAudio;
/// <summary>
/// Audio capture mode for audio remoting.
/// </summary>
public RemotingAudioCaptureMode AudioCaptureMode;
/// <summary>
/// Configuration to enable secure connection.
/// </summary>
public SecureRemotingConnectConfiguration? secureConnectConfiguration;
}
/// <summary>
/// Specifies the configuration for the remote app (Client) to initiate a secure remoting connection.
/// </summary>
public struct SecureRemotingConnectConfiguration
{
///<summary>
/// Shared token between the remote app (Client) and remote player (Server).
/// Used by remote player (Server) to validate the remote app (Client)
/// before establishing a secure connection. For more details, reference the
/// <see href=" https://docs.microsoft.com/windows/mixed-reality/develop/native/holographic-remoting-secure-connection#planning-the-client-to-server-authentication">client to server authentication</see>.
///</summary>
public string AuthenticationToken;
///<summary>
/// Specify whether to request platform's default validation on the remote player's certificate using
/// the validation functions of the underlying operating system or cryptography library.This bool is
/// taken into account only when <see cref="AppRemoting.ValidateServerCertificate"/> callback is implemented
/// by the remote app (Client). Otherwise, if the callback is not provided system validation is performed
/// regardless and is used for validating the remoting player's(Server) certificate.
///</summary>
public bool PerformSystemValidation;
/// <summary>
/// The callback function to validate the certificate chain provided by the remote player (Server).
/// </summary>
public SecureRemotingValidateServerCertificateDelegate ValidateServerCertificateCallback;
}
/// <summary>
/// Defines the result of a certificate validation for secure remoting connection.
/// </summary>
[Serializable, StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct SecureRemotingCertificateValidationResult
{
///<summary>
/// Specifies whether the certificate can be traced back to a trusted root
///</summary>
public bool TrustedRoot;
///<summary>
/// Specifies whether the certificate has been revoked
///</summary>
public bool Revoked;
///<summary>
/// Specifies whether the certificate is outside of its validity period (expired or not yet valid)
///</summary>
public bool Expired;
///<summary>
/// Specifies whether the allowed certificate usage is not compatible with its actual usage
///</summary>
public bool WrongUsage;
///<summary>
/// Specifies whether the revocation check failed
///</summary>
public bool RevocationCheckFailed;
///<summary>
/// Specifies whether the certificate to validate and/or certificate(s) in the certificate chain
/// contained invalid data and could not be examined
///</summary>
public bool InvalidCertOrChain;
///<summary>
/// Specifies the result of name validation, if there is a name mismatch between
/// the name of the host presenting the certificate and the certificate subject
///</summary>
public SecureRemotingNameValidationResult NameValidationResult;
}
/// <summary>
/// Describes whether the name of the host presenting the certificate does not match the certificate subject.
/// </summary>
public enum SecureRemotingNameValidationResult
{
///<summary>
/// Represents that the name match cannot be reliably determined.
///</summary>
ResultIndeterminate = 0,
///<summary>
/// Represents the name of the host presenting the certificate matches the certificate subject.
///</summary>
ResultMatch = 1,
///<summary>
/// Represents the name of the host presenting the certificate does not match the certificate subject.
///</summary>
ResultMismatch = 2,
}
/// <summary>
/// Defines the callback that can be provided by the remote app (Client) for custom validation of remote player's(Server) certificate chain.
/// </summary>
/// <param name="hostName">The name of the host the connection is being established with</param>
/// <param name="serverCertificateChain">The certificate chain that the server provides when initiating the secure connection</param>
/// <param name="systemValidationResult">The result of system validation is provided by remoting runtime if system validation is requested by the remote app</param>
/// <returns> Returns custom server certificated validation result.</returns>
/// <remarks> System validation (as the name suggests) is certificate validation based on the underlying system’s cryptographic APIs and certificate stores.
/// Thus, results can vary depending on OS and local setup. The system validators are implemented in libbasix, which is owned by the RDV project.
/// System validation in this API will forward to libbasix’ default validators for the respective platform
/// </remarks>
public delegate SecureRemotingCertificateValidationResult SecureRemotingValidateServerCertificateDelegate(string hostName,
X509Certificate2Collection serverCertificateChain,
SecureRemotingCertificateValidationResult? systemValidationResult = null);
/// <summary>
/// Specifies the configuration for the remote app (Server) to initiate a remoting connection in listen mode.
/// </summary>
[Serializable, StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct RemotingListenConfiguration
{
/// <summary>
/// The host name or IP address of the player running in network server mode to connect to.
/// </summary>
public string ListenInterface;
/// <summary>
/// The port number of the server's handshake port.
/// </summary>
public ushort HandshakeListenPort;
/// <summary>
/// The port number of the server's transport port.
/// </summary>
public ushort TransportListenPort;
/// <summary>
/// The max bitrate in Kbps to use for the connection.
/// </summary>
public uint MaxBitrateKbps;
/// <summary>
/// The video codec to use for the connection.
/// </summary>
public RemotingVideoCodec VideoCodec;
/// <summary>
/// Enable/disable audio remoting.
/// </summary>
public bool EnableAudio;
/// <summary>
/// Audio capture mode for audio remoting.
/// </summary>
public RemotingAudioCaptureMode AudioCaptureMode;
/// <summary>
/// Configuration to enable secure connection.
/// </summary>
public SecureRemotingListenConfiguration? secureListenConfiguration;
}
/// <summary>
/// Specifies the configuration for the remote app (Server) to initiate a secure remoting connection in linsten mode.
/// </summary>
public struct SecureRemotingListenConfiguration
{
/// <summary>
/// Byte array containing a certificate store in PKCS#12 format. This store must contain the server
/// certificate and the associated private key; optionally, it can also contain the certificate chain for the server certificate.
/// </summary>
public NativeArray<byte> Certificate;
/// <summary>
/// The name of the server certificate which is used to identify it in the
/// certificate store. This is usually either the subject common name, or a friendly name assigned to the certificate.
/// </summary>
public string SubjectName;
/// <summary>
/// The passphrase needed to decrypt the private key. Can be an empty string
/// if the private key is not encrypted.
/// </summary>
/// <remarks>
/// The passphrase is passed on as UTF-8 encoded and thus, depending on the encoding used when
/// writing the certificate store, passphrases containing characters beyond the 7-bit ASCII range may not work as expected.
/// </remarks>
public string KeyPassphrase;
/// <summary>
/// The callback function to validate authentication token provided by the remoting player (Client).
///</summary>
public SecureRemotingValidateAuthenticationTokenDelegate ValidateAuthenticationTokenCallback;
}
/// <summary>
/// The callback that needs to be implemented by remote app (Server) in secure listen mode
/// to validate remote player's (Client) authentication token.
/// </summary>
/// <param name="authenticationTokenToCheck">shared secret between the client and server.
/// Used to validate the remote player to establish a secure connection.</param>
/// <returns> Returns true if the token validation succeeds and false if not.</returns>
public delegate bool SecureRemotingValidateAuthenticationTokenDelegate(string authenticationTokenToCheck);
/// <summary>
/// Describes the current connection state.
/// </summary>
public enum ConnectionState
{
/// <summary>
/// Represents that the state is not connected, and no connection attempt is
/// in progress (Client), or not listening for incoming connections (Server).
/// </summary>
Disconnected = 0,
/// <summary>
/// Represents connecting to server (Client), listening for incoming
/// connections (Server), or performing connection handshake (Client/Server).
/// </summary>
Connecting = 1,
/// <summary>
/// Represents fully connected, all communication channels established (Client/Server).
/// </summary>
Connected = 2,
}
/// <summary>
/// Describes the reason for why the connection disconnected.
/// </summary>
public enum DisconnectReason
{
/// <summary>
/// The connection succeeded and there was no connection failure.
/// </summary>
None = 0,
/// <summary>
/// The connection failed for an unknown reason.
/// </summary>
Unknown = 1,
/// <summary>
/// The secure connection was enabled, but certificate was missing, invalid, or not usable (Server).
/// </summary>
NoServerCertificate = 2,
/// <summary>
/// The handshake port could not be opened for accepting connections (Server).
/// </summary>
HandshakePortBusy = 3,
/// <summary>
/// The handshake server is unreachable (Client).
/// </summary>
HandshakeUnreachable = 4,
/// <summary>
/// The handshake server closed the connection prematurely; likely due to TLS/Plain mismatch or invalid certificate (Client).
/// </summary>
HandshakeConnectionFailed = 5,
/// <summary>
/// The authentication with the handshake server failed (Client).
/// </summary>
AuthenticationFailed = 6,
/// <summary>
/// No common compatible remoting version could be determined during handshake (Client).
/// </summary>
RemotingVersionMismatch = 7,
/// <summary>
/// No common transport protocol could be determined during handshake (Client).
/// </summary>
IncompatibleTransportProtocols = 8,
/// <summary>
/// The handshake failed for any other reason (Client).
/// </summary>
HandshakeFailed = 9,
/// <summary>
/// The transport port could not be opened for accepting connections (Server).
/// </summary>
TransportPortBusy = 10,
/// <summary>
/// The transport server is unreachable (Client).
/// </summary>
TransportUnreachable = 11,
/// <summary>
/// The transport connection was closed before all communication channels had been set up (Client/Server).
/// </summary>
TransportConnectionFailed = 12,
/// <summary>
/// The transport connection was closed due to protocol version mismatch (Client/Server).
/// </summary>
ProtocolVersionMismatch = 13,
/// <summary>
/// A protocol error occurred that was severe enough to invalidate the current connection or connection attempt (Client/Server).
/// </summary>
ProtocolError = 14,
/// <summary>
/// The transport connection was closed due to the requested video codec not being available (Client/Server).
/// </summary>
VideoCodecNotAvailable = 15,
/// <summary>
/// The connection attempt has been canceled (Client/Server).
/// </summary>
Canceled = 16,
/// <summary>
/// The connection has been closed by peer (Client/Server).
/// </summary>
ConnectionLost = 17,
/// <summary>
/// The connection has been closed due to graphics device loss (Client/Server).
/// </summary>
DeviceLost = 18,
/// <summary>
/// The connection has been closed by request (Client/Server).
/// </summary>
DisconnectRequest = 19,
/// <summary>
/// The network is unreachable. This usually means the client knows no route to reach the remote host (Client).
/// </summary>
HandshakeNetworkUnreachable = 20,
/// <summary>
/// No connection could be made because the remote side actively refused it. Usually this means that no host application is running (Client).
/// </summary>
HandshakeConnectionRefused = 21,
/// <summary>
/// The transport connection was closed due to the requested video format not being available (Client/Server).
/// </summary>
VideoFormatNotAvailable = 22,
/// <summary>
/// Disconnected after receiving a disconnect request from the peer (Client/Server).
/// </summary>
PeerDisconnectRequest = 23,
/// <summary>
/// Timed out while waiting for peer to close connection (Client/Server).
/// </summary>
PeerDisconnectTimeout = 24,
/// <summary>
/// Timed out while waiting for transport session to be opened (Client/Server).
/// </summary>
SessionOpenTimeout = 25,
/// <summary>
/// Timed out while waiting for the remoting handshake to complete (Client/Server).
/// </summary>
RemotingHandshakeTimeout = 26,
/// <summary>
/// The connection failed due to an internal error (Client/Server).
/// </summary>
InternalError = 27,
/// <summary>
/// The handshake could not be opened due to insufficient permissions (Client).
/// </summary>
HandshakePermissionDenied = 28,
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/AppRemoting.cs.meta Normal file
View File

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

211
com.microsoft.mixedreality.openxr/Runtime/API/ControllerModel.cs Normal file
View File

@ -0,0 +1,211 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma warning disable CS0618 // Suppress deprecation warnings
using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Provides access to a byte stream representing a glTF model of the current controller.
/// </summary>
#if UNITY_ANDROID
[Obsolete("The Motion Controller Model feature plugin from the Mixed Reality OpenXR Plugin has been deprecated on Android. For apps using Android motion controller models, we recommend transitioning to the OpenXR plugins from Unity and Meta.", false)]
#endif
public class ControllerModel
{
private static MotionControllerFeaturePlugin Feature => OpenXRFeaturePlugin<MotionControllerFeaturePlugin>.Feature;
/// <summary>
/// The user's left controller.
/// </summary>
public static ControllerModel Left { get; } = new ControllerModel(Handedness.Left);
/// <summary>
/// The user's right controller.
/// </summary>
public static ControllerModel Right { get; } = new ControllerModel(Handedness.Right);
private readonly Handedness m_handedness;
internal ControllerModel(Handedness trackerHandedness)
{
m_handedness = trackerHandedness;
}
/// <summary>
/// Returns true if the necessary OpenXR feature extensions are enabled on the current runtime.
/// </summary>
/// <remarks>This value should not be assumed immutable and should be queried on a new XR session.</remarks>
public static bool IsSupported => Feature.IsValidAndEnabled() && NativeLib.IsControllerModelSupported();
/// <summary>
/// Provides access to a model-specific key to either load a new model or use to cache loaded models.
/// </summary>
/// <param name="modelKey">The unique key representing this controller's model, if one exists.</param>
/// <returns>True if a valid key could be retrieved. False otherwise.</returns>
public bool TryGetControllerModelKey(out ulong modelKey)
{
if (!IsSupported || OpenXRContext.Current.Session == 0)
{
modelKey = 0;
return false; // Controller feature is not enabled.
}
return NativeLib.TryGetControllerModelKey(m_handedness, out modelKey);
}
/// <summary>
/// Provides a byte stream representing the glTF model of the controller, if available.
/// </summary>
/// <remarks>
/// Needs to be passed into a glTF parser/loader to convert into a Unity GameObject.
/// This method allocates a byte buffer on every successful call. It's recommended to either cache it or the resulting GameObject locally instead of calling this multiple times.
/// </remarks>
/// <param name="modelKey">The unique key representing the desired controller's model. Can be queried using <see cref="TryGetControllerModelKey"/>.</param>
/// <returns>Task that triggers once the controller model stream is loaded, yielding the stream or null if there is no model available.</returns>
public Task<byte[]> TryGetControllerModel(ulong modelKey)
{
if (!IsSupported || OpenXRContext.Current.Session == 0)
{
return Task.FromResult<byte[]>(null); // Controller feature is not enabled.
}
Task<byte[]> newTask = Task.Run(() =>
{
if (NativeLib.TryGetControllerModel(modelKey, 0, out uint bufferCapacity))
{
byte[] modelBuffer = new byte[bufferCapacity];
if (NativeLib.TryGetControllerModel(modelKey, bufferCapacity, out _, modelBuffer))
{
return modelBuffer;
}
}
return null;
});
return newTask;
}
private uint m_lastNodeStateCount = 0;
/// <summary>
/// Represents a set of animatable nodes in the controller model. Use <see cref="TryGetControllerModelState"/> to obtain the current animation values.
/// </summary>
/// <param name="modelKey">The unique key representing the desired controller's model. Can be queried using <see cref="ControllerModel.TryGetControllerModelKey"/>.</param>
/// <param name="modelRoot">The Transform representing the loaded controller model from <see cref="ControllerModel.TryGetControllerModel"/>.</param>
/// <param name="nodes">A method-allocated array containing the animatable nodes in the current controller model, with the same indices as the Pose array data from <see cref="TryGetControllerModelState"/>.</param>
/// <remarks>
/// This method allocates a Transform array on every successful call.
/// It's recommended to cache it locally instead of calling this multiple times, as this won't change unless the model key changes.
/// </remarks>
internal bool TryGetControllerModelProperties(ulong modelKey, Transform modelRoot, out Transform[] nodes)
{
if (IsSupported && OpenXRContext.Current.Session != 0 &&
NativeLib.TryGetControllerModelProperties(modelKey, 0, out uint nodeCountOutput))
{
m_lastNodeStateCount = nodeCountOutput;
ControllerModelNodeProperties[] properties = new ControllerModelNodeProperties[nodeCountOutput];
if (NativeLib.TryGetControllerModelProperties(modelKey, nodeCountOutput, out _, properties))
{
nodes = new Transform[nodeCountOutput];
Transform[] children = modelRoot.GetComponentsInChildren<Transform>();
int nodesFound = 0;
// Iterates through all children of the model root in order to find the
// animatable nodes by name plus parent name (if provided).
foreach (Transform potentialNode in children)
{
// If we've found all named nodes, we can return early.
if (nodesFound == nodeCountOutput)
{
break;
}
for (int i = 0; i < nodeCountOutput; i++)
{
// Because we iterate through all node names for each node, it's possible that this node has already been found.
if (nodes[i] != null)
{
continue;
}
ControllerModelNodeProperties property = properties[i];
if (potentialNode.name.Equals(property.NodeName, StringComparison.OrdinalIgnoreCase)
&& (string.IsNullOrWhiteSpace(property.ParentNodeName)
|| (potentialNode.parent != null && potentialNode.parent.name.Equals(property.ParentNodeName, StringComparison.OrdinalIgnoreCase))))
{
nodes[i] = potentialNode;
nodesFound++;
break;
}
}
}
// If we didn't find all nodes, log which ones are missing.
if (nodesFound != nodeCountOutput)
{
for (int i = 0; i < nodeCountOutput; i++)
{
if (nodes[i] == null)
{
Debug.LogError($"No corresponding node found for node name {properties[i].NodeName} and parent name {properties[i].ParentNodeName}.");
}
}
}
return nodesFound == nodeCountOutput;
}
}
nodes = Array.Empty<Transform>();
return false;
}
/// <summary>
/// Represents the current state of the controller model representing user's interaction to the controller, such as pressing a button or pulling a trigger.
/// </summary>
/// <param name="modelKey">The unique key representing the desired controller's model. Can be queried using <see cref="ControllerModel.TryGetControllerModelKey"/>.</param>
/// <param name="poses"></param>
/// <exception cref="ArgumentException">The pose array must match the properties array size of the most recent call to <see cref="TryGetControllerModelProperties"/>.</exception>
internal bool TryGetControllerModelState(ulong modelKey, Pose[] poses)
{
if (!IsSupported || OpenXRContext.Current.Session == 0)
{
return false;
}
if (poses.Length != m_lastNodeStateCount)
{
throw new ArgumentException("The poses array doesn't match the most recent array size from TryGetControllerModelProperties.");
}
return NativeLib.TryGetControllerModelState(modelKey, m_lastNodeStateCount, out _, poses);
}
/// <summary>
/// Describes properties of animatable nodes, including the node name and parent node name to locate a glTF node in the controller model that can be animated based on user's interactions on the controller.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Ansi)]
internal readonly struct ControllerModelNodeProperties
{
// Represents the maximum name size defined by the OpenXR spec. Used for string marshaling.
private const int ControllerModelNodeNameSize = 64;
/// <summary>
/// The name of the parent node in the provided glTF file.
/// </summary>
/// <remarks>The parent name may be empty if it should not be used to locate this node.</remarks>
[field: MarshalAs(UnmanagedType.ByValTStr, SizeConst = ControllerModelNodeNameSize)]
public string ParentNodeName { get; }
/// <summary>
/// The name of this node in the provided glTF file.
/// </summary>
[field: MarshalAs(UnmanagedType.ByValTStr, SizeConst = ControllerModelNodeNameSize)]
public string NodeName { get; }
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ControllerModel.cs.meta Normal file
View File

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

87
com.microsoft.mixedreality.openxr/Runtime/API/ControllerModelArticulator.cs Normal file
View File

@ -0,0 +1,87 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma warning disable CS0618 // Suppress deprecation warnings
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Handles articulation of the animatable parts of a controller model.
/// </summary>
public class ControllerModelArticulator : MonoBehaviour
{
private ControllerModel m_controllerModel = null;
private ulong m_modelKey = 0;
private Transform[] m_animationNodes = null;
private Pose[] m_poses = null;
private bool IsArticulating => m_controllerModel != null && m_modelKey != 0;
/// <summary>
/// Tries to start active articulation of this controller model.
/// </summary>
/// <param name="controllerModel">The reference to the controller model this component represents. See <see cref="ControllerModel.Left"/> and <see cref="ControllerModel.Right"/>.</param>
/// <param name="modelKey">The model key corresponding to the loaded controller model. See <see cref="ControllerModel.TryGetControllerModelKey(out ulong)"/>.</param>
/// <returns>True if the controller model supports part articulation and articulation was actively started.</returns>
public bool TryStartArticulating(ControllerModel controllerModel, ulong modelKey)
{
if (controllerModel.TryGetControllerModelProperties(modelKey, transform, out m_animationNodes))
{
m_controllerModel = controllerModel;
m_modelKey = modelKey;
// For updating the node poses in Update. This needs to be the same length as the number of nodes.
if (m_poses == null || m_poses.Length != m_animationNodes.Length)
{
m_poses = new Pose[m_animationNodes.Length];
}
}
else
{
// Disable the built-in, auto-playing glTF animations in the Quest model.
Animation[] animations = GetComponentsInChildren<Animation>();
foreach (Animation animation in animations)
{
animation.enabled = false;
}
}
return IsArticulating;
}
/// <summary>
/// Stops any active articulation of this controller model.
/// </summary>
public void StopArticulating()
{
m_controllerModel = null;
m_modelKey = 0;
}
/// <summary>
/// The MonoBehaviour Update() callback.
/// </summary>
protected void Update()
{
if (IsArticulating
&& m_poses != null
&& m_animationNodes != null
&& m_controllerModel.TryGetControllerModelState(m_modelKey, m_poses))
{
for (int i = 0; i < m_poses.Length; i++)
{
Transform node = m_animationNodes[i];
Pose pose = m_poses[i];
#if UNITY_2021_3_11_OR_NEWER
node.SetLocalPositionAndRotation(pose.position, pose.rotation);
#else
node.localPosition = pose.position;
node.localRotation = pose.rotation;
#endif
}
}
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ControllerModelArticulator.cs.meta Normal file
View File

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

102
com.microsoft.mixedreality.openxr/Runtime/API/EyeLevelSceneOrigin.cs Normal file
View File

@ -0,0 +1,102 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEngine;
using UnityEngine.XR;
using UnityEngine.XR.Management;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Add the EyeLevelSceneOrigin component to the scene, it will automatically
/// switch the Unity's scene origin to an eye level experiences.
/// It will try to use "Unbounded" origin mode when it's supported.
/// </summary>
[System.Obsolete("Obsolete and will be removed in future releases. " +
"Use MRTK3 Microsoft.MixedReality.Toolkit.Input.UnboundedTrackingMode instead for HoloLens 2 application using Unbounded space." +
"Or use Unity.​XR.​Core​Utils.XROrigin for other XR applications.", false)]
public class EyeLevelSceneOrigin : MonoBehaviour
{
private XRInputSubsystem m_inputSubsystem;
private ulong m_currentSession = 0;
private static XRInputSubsystem GetXRInputSubsystem()
{
XRGeneralSettings xrSettings = XRGeneralSettings.Instance;
if (xrSettings != null)
{
XRManagerSettings xrManager = xrSettings.Manager;
if (xrManager != null)
{
XRLoader xrLoader = xrManager.activeLoader;
if (xrLoader != null)
{
return xrLoader.GetLoadedSubsystem<XRInputSubsystem>();
}
}
}
return null;
}
private void Update()
{
if (m_currentSession != OpenXRContext.Current.Session)
{
m_currentSession = OpenXRContext.Current.Session;
if (m_inputSubsystem != null)
{
m_inputSubsystem.trackingOriginUpdated -= XrInputSubsystem_trackingOriginUpdated;
m_inputSubsystem = null; // reset input subsystem reference on a new OpenXR session.
}
}
// Lazy initialize input subsystem.
if (m_inputSubsystem == null && OpenXRContext.Current.IsSessionRunning)
{
m_inputSubsystem = GetXRInputSubsystem();
if (m_inputSubsystem != null)
{
EnsureSceneOriginAtEyeLevel(m_inputSubsystem);
m_inputSubsystem.trackingOriginUpdated += XrInputSubsystem_trackingOriginUpdated;
}
}
}
private void XrInputSubsystem_trackingOriginUpdated(XRInputSubsystem xrInputSubsystem)
{
if (OpenXRContext.Current.IsSessionRunning && xrInputSubsystem == m_inputSubsystem)
{
EnsureSceneOriginAtEyeLevel(m_inputSubsystem);
}
}
private static void EnsureSceneOriginAtEyeLevel(XRInputSubsystem xrInputSubsystem)
{
TrackingOriginModeFlags currentMode = xrInputSubsystem.GetTrackingOriginMode();
TrackingOriginModeFlags desiredMode = GetDesiredTrackingOriginMode(xrInputSubsystem);
bool isEyeLevel = currentMode == TrackingOriginModeFlags.Device || currentMode == TrackingOriginModeFlags.Unbounded;
if (!isEyeLevel || currentMode != desiredMode)
{
Debug.Log($"EyeLevelSceneOrigin: TrySetTrackingOriginMode to {desiredMode}");
if (!xrInputSubsystem.TrySetTrackingOriginMode(desiredMode))
{
Debug.LogWarning($"EyeLevelSceneOrigin: Failed to set tracking origin to {desiredMode}.");
}
}
}
private static TrackingOriginModeFlags GetDesiredTrackingOriginMode(XRInputSubsystem xrInputSubsystem)
{
TrackingOriginModeFlags supportedFlags = xrInputSubsystem.GetSupportedTrackingOriginModes();
TrackingOriginModeFlags targetFlag = TrackingOriginModeFlags.Device; // All OpenXR runtime must support LOCAL space
if (supportedFlags.HasFlag(TrackingOriginModeFlags.Unbounded))
{
targetFlag = TrackingOriginModeFlags.Unbounded;
}
return targetFlag;
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/EyeLevelSceneOrigin.cs.meta Normal file
View File

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

21
com.microsoft.mixedreality.openxr/Runtime/API/FrameTime.cs Normal file
View File

@ -0,0 +1,21 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Choose the predicted display time of a frame in pipelined rendering.
/// </summary>
public enum FrameTime
{
/// <summary>
/// The time in update thread using previous frame's predicted time + duration.
/// </summary>
OnUpdate = 0,
/// <summary>
/// The time in render thread using current frame's predicted time.
/// </summary>
OnBeforeRender
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/FrameTime.cs.meta Normal file
View File

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

363
com.microsoft.mixedreality.openxr/Runtime/API/GestureRecognizer.cs Normal file
View File

@ -0,0 +1,363 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Represents the set of gestures that may be recognized by a GestureRecognizer.
/// </summary>
[Flags]
public enum GestureSettings
{
/// <summary>
/// An empty gesture setting
/// </summary>
None = 0,
/// <summary>
/// A single air tap.
/// </summary>
Tap = 1,
/// <summary>
/// A double air tap
/// </summary>
DoubleTap = 1 << 1,
/// <summary>
/// Hold at the end of air tap
/// </summary>
Hold = 1 << 2,
/// <summary>
/// Manipulate gesture to control X, Y, and Z translations.
/// </summary>
ManipulationTranslate = 1 << 3,
/// <summary>
/// Navigation gesture at X direction.
/// </summary>
NavigationX = 1 << 4,
/// <summary>
/// Navigation gesture at Y direction.
/// </summary>
NavigationY = 1 << 5,
/// <summary>
/// Navigation gesture at Z direction.
/// </summary>
NavigationZ = 1 << 6,
/// <summary>
/// Navigation gesture at X direction and suppress Y and Z direction.
/// </summary>
NavigationRailsX = 1 << 7,
/// <summary>
/// Navigation gesture at Y direction and suppress X and Z direction.
/// </summary>
NavigationRailsY = 1 << 8,
/// <summary>
/// Navigation gesture at Z direction and suppress X and Y direction.
/// </summary>
NavigationRailsZ = 1 << 9,
}
/// <summary>
/// Represents the type of gesture recognizer event
/// </summary>
public enum GestureEventType
{
/// <summary>
/// Indicates a new recognition is started.
/// </summary>
RecognitionStarted,
/// <summary>
/// Indicates the recognition is ended.
/// </summary>
RecognitionEnded,
/// <summary>
/// Indicates a tap is detected.
/// </summary>
Tapped,
/// <summary>
/// Indicates a hold gesture is detected.
/// </summary>
HoldStarted,
/// <summary>
/// Indicates a hold gesture is completed.
/// </summary>
HoldCompleted,
/// <summary>
/// Indicates a hold gesture is canceled.
/// </summary>
HoldCanceled,
/// <summary>
/// Indicates a manipulation gesture is started.
/// </summary>
ManipulationStarted,
/// <summary>
/// Indicates a manipulation gesture is updating the input location.
/// </summary>
ManipulationUpdated,
/// <summary>
/// Indicates a manipulation gesture is completed.
/// </summary>
ManipulationCompleted,
/// <summary>
/// Indicates a manipulation gesture is canceled.
/// </summary>
ManipulationCanceled,
/// <summary>
/// Indicates a navigation gesture is started.
/// </summary>
NavigationStarted,
/// <summary>
/// Indicates a navigation gesture is updating the input location.
/// </summary>
NavigationUpdated,
/// <summary>
/// Indicates a navigation gesture is completed.
/// </summary>
NavigationCompleted,
/// <summary>
/// Indicates a navigation gesture is canceled.
/// </summary>
NavigationCanceled,
}
/// <summary>
/// Represents the hand that initiated the gesture.
/// </summary>
public enum GestureHandedness
{
/// <summary>
/// The gesture is not associated with any specific hand, for example when a gesture is triggered by voice command.
/// </summary>
Unspecified,
/// <summary>
/// The gesture is initiated by left hand.
/// </summary>
Left,
/// <summary>
/// The gesture is initiated by right hand.
/// </summary>
Right,
}
/// <summary>
/// The data of a gesture event, include the event type, handedness, poses etc.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct GestureEventData
{
/// <summary>
/// Get the type of gesture event.
/// </summary>
public GestureEventType EventType => nativeData.eventType;
/// <summary>
/// Get which hand triggers this gesture event, or it's not related to specific hand.
/// </summary>
public GestureHandedness Handedness => nativeData.handedness;
/// <summary>
/// Get the data for tap or double tap event.
/// It only has value if and only if the eventType == GestureEventType.Tapped
/// </summary>
public TappedEventData? TappedData => nativeData.Get<TappedEventData>(nativeData.tappedData, nativeData.IsTappedEvent());
/// <summary>
/// Get the data for manipulation gesture event.
/// It only has value if and only if the eventType == GestureEventType.ManipulationStarted/Updated/Completed
/// </summary>
public ManipulationEventData? ManipulationData => nativeData.Get<ManipulationEventData>(nativeData.manipulationData, nativeData.IsManipulationEvent());
/// <summary>
/// Get the data for navigation gesture event.
/// It only has value if and only if the eventType == GestureEventType.NavigationStarted/Updated/Completed
/// </summary>
public NavigationEventData? NavigationData => nativeData.Get<NavigationEventData>(nativeData.navigationData, nativeData.IsNavigationEvent());
private readonly NativeGestureEventData nativeData;
}
/// <summary>
/// The data of a tap gesture event
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct TappedEventData
{
/// <summary>
/// The tap number represented by this gesture, either 1 or 2.
/// </summary>
public uint TapCount;
}
/// <summary>
/// The data of a manipulation gesture event
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct ManipulationEventData
{
/// <summary>
/// Get the relative translation of the hand since the start of a Manipulation gesture.
/// </summary>
public Vector3 CumulativeTranslation;
}
/// <summary>
/// The data of a navigation gesture event
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct NavigationEventData
{
/// <summary>
/// Gets whether the navigation gesture the user is performing involves motion on the horizontal axis.
/// </summary>
public bool IsNavigatingX => m_directionFlags.HasFlag(NativeDirectionFlags.X);
/// <summary>
/// Gets whether the navigation gesture the user is performing involves motion on the vertical axis.
/// </summary>
public bool IsNavigatingY => m_directionFlags.HasFlag(NativeDirectionFlags.Y);
/// <summary>
/// Gets whether the navigation gesture the user is performing involves motion on the depth axis.
/// </summary>
public bool IsNavigatingZ => m_directionFlags.HasFlag(NativeDirectionFlags.Z);
/// <summary>
/// Gets the normalized offset of the hand or motion controller within the unit cube for all axes for this Navigation gesture.
/// </summary>
/// <remarks> X direction is from left to right. Y direction is from bottom to top. Z direction is from back to forward.</remarks>
public Vector3 NormalizedOffset;
private NativeDirectionFlags m_directionFlags;
}
/// <summary>
/// A gesture recognizer interprets user interactions from hands, motion controllers, and system voice commands
/// to surface spatial gesture events, which users target using their gaze or hand's pointing ray.
/// </summary>
public class GestureRecognizer
{
/// <summary>
/// Create a new GestureRecognizer using the given settings.
/// </summary>
/// <remarks>If the given setting is not compatible, the new GestureRecognizer will still be created,
/// though it won't produce any gesture event. The setting can be corrected later through the GestureSettings property.</remarks>
public GestureRecognizer(GestureSettings settings)
{
GestureSettings = settings;
}
/// <summary>
/// Set the gesture settings to configure which gestures to recognize.
/// </summary>
public GestureSettings GestureSettings
{
get { return m_requestedSettings; }
set
{
if (m_requestedSettings != value)
{
m_requestedSettings = value;
if (m_gestureSubsystem != null)
{
m_gestureSubsystem.GestureSettings = value;
}
else
{
m_gestureSubsystem = GestureSubsystem.TryCreateGestureSubsystem(value);
}
}
}
}
/// <summary>
/// Start monitor the user interactions and recognize the configured gestures.
/// </summary>
public void Start()
{
if (m_gestureSubsystem != null)
{
m_gestureSubsystem.Start();
}
}
/// <summary>
/// Stop monitor the user interactions
/// </summary>
public void Stop()
{
if (m_gestureSubsystem != null)
{
m_gestureSubsystem.Stop();
}
}
/// <summary>
/// Get the next gesture recognition event data, or return false when the event queue is empty.
/// </summary>
/// <param name="eventData">App allocated data struct to receive the data.</param>
/// <remarks>If function returns false, the content in eventData is undefined and should be avoided.</remarks>
public bool TryGetNextEvent(ref GestureEventData eventData)
{
return m_gestureSubsystem != null && m_gestureSubsystem.TryGetNextEvent(ref eventData);
}
/// <summary>
/// Cancel all pending gestures and reset to initial state. All events in the queue will be discarded.
/// </summary>
public void CancelPendingGestures()
{
if (m_gestureSubsystem != null)
{
m_gestureSubsystem.CancelPendingGestures();
}
}
/// <summary>
/// Destroy the GestureRecognizer when the application is done with it.
/// </summary>
public void Destroy()
{
if (m_gestureSubsystem != null)
{
m_gestureSubsystem.Dispose();
m_gestureSubsystem = null;
}
}
/// <summary>
/// Destroy the GestureRecognizer when the application is done with it.
/// </summary>
[Obsolete("Obsolete and will be removed in future releases. Use the Destroy() function at appropriated place instead.")]
public void Dispose()
{
Destroy();
}
private GestureSubsystem m_gestureSubsystem;
private GestureSettings m_requestedSettings;
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/GestureRecognizer.cs.meta Normal file
View File

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

138
com.microsoft.mixedreality.openxr/Runtime/API/HandMeshTracker.cs Normal file
View File

@ -0,0 +1,138 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Represents different possible hand poses.
/// </summary>
/// <remarks>See https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandPoseTypeMSFT for more information.</remarks>
public enum HandPoseType
{
/// <summary>
/// Represents a hand pose provided by actual tracking of the user's hand.
/// </summary>
Tracked = 0,
/// <summary>
/// Represents a stable reference hand pose in a relaxed open hand shape.
/// </summary>
ReferenceOpenPalm,
}
/// <summary>
/// Represents a user's hand and the ability to render a hand mesh representation of it.
/// </summary>
public class HandMeshTracker
{
/// <summary>
/// The user's left hand.
/// </summary>
public static HandMeshTracker Left { get; } = new HandMeshTracker(Handedness.Left);
/// <summary>
/// The user's right hand.
/// </summary>
public static HandMeshTracker Right { get; } = new HandMeshTracker(Handedness.Right);
private HandTrackingFeaturePlugin Feature => OpenXRFeaturePlugin<HandTrackingFeaturePlugin>.Feature;
private readonly Handedness m_handedness;
private Vector3[] m_handMeshVertices = null;
private Vector3[] m_handMeshNormals = null;
private int[] m_handMeshIndices = null;
private Mesh m_currentMesh = null;
private uint m_indexBufferKey = 0;
private ulong m_vertexBufferkey = 0;
private HandMeshTracker(Handedness trackerHandedness)
{
m_handedness = trackerHandedness;
}
/// <summary>
/// Tries to get the current location in world-space of the specified hand mesh.
/// </summary>
/// <param name="frameTime">Specify the <see cref="FrameTime"/> to locate the hand mesh.</param>
/// <param name="pose">The current pose of the specified hand mesh.</param>
/// <param name="handPoseType">The type of hand mesh pose to request. The tracked pose represents the actively tracked hand. The reference pose represents a stable hand pose in a relaxed open hand shape.</param>
/// <returns>Returns true when the returned pose is tracking and valid to be used.
/// Returns false when the hand mesh tracker lost tracking or it's not properly set up.</returns>
public bool TryLocateHandMesh(FrameTime frameTime, out Pose pose, HandPoseType handPoseType = HandPoseType.Tracked)
{
pose = Pose.identity;
return Feature.IsValidAndEnabled() && OpenXRContext.Current.IsSessionRunning
&& NativeLib.TryLocateHandMesh(m_handedness, frameTime, handPoseType, out pose);
}
/// <summary>
/// Retrieves the latest hand mesh information and build the current hand mesh in the passed-in mesh parameter.
/// </summary>
/// <param name="frameTime">Specify the <see cref="FrameTime"/> to locate the hand mesh.</param>
/// <param name="handMesh">The mesh object to build the hand mesh in.</param>
/// <param name="handPoseType">The type of hand mesh to request. The tracked pose represents the actively tracked hand. The reference pose represents a stable hand pose in a relaxed open hand shape.</param>
/// <returns>True if the mesh was retrievable.</returns>
public bool TryGetHandMesh(FrameTime frameTime, Mesh handMesh, HandPoseType handPoseType = HandPoseType.Tracked)
{
if (!Feature.IsValidAndEnabled() || !OpenXRContext.Current.IsSessionRunning)
{
return false; // Hand tracking feature is not enabled. Return the tracker not tracking.
}
try
{
if (m_handMeshVertices == null || m_handMeshNormals == null || m_handMeshIndices == null)
{
if (NativeLib.TryGetHandMeshBufferSizes(out uint maxVertexCount, out uint maxIndexCount))
{
m_handMeshVertices = new Vector3[maxVertexCount];
m_handMeshNormals = new Vector3[maxVertexCount];
m_handMeshIndices = new int[maxIndexCount];
}
else
{
return false;
}
}
if (m_currentMesh != handMesh)
{
m_currentMesh = handMesh;
m_indexBufferKey = 0;
m_vertexBufferkey = 0;
}
if (NativeLib.TryGetHandMesh(m_handedness, frameTime, handPoseType,
ref m_vertexBufferkey, out uint vertexCount, m_handMeshVertices, m_handMeshNormals,
ref m_indexBufferKey, out uint indexCount, m_handMeshIndices))
{
// The NativeLib call will return a count of 0 if no change was made
if (vertexCount > 0)
{
handMesh.SetVertices(m_handMeshVertices, 0, (int)vertexCount);
handMesh.SetNormals(m_handMeshNormals, 0, (int)vertexCount);
}
if (indexCount > 0)
{
handMesh.SetTriangles(m_handMeshIndices, 0, (int)indexCount, 0);
}
return true;
}
else
{
return false;
}
}
catch (System.DllNotFoundException)
{
return false;
}
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/HandMeshTracker.cs.meta Normal file
View File

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

267
com.microsoft.mixedreality.openxr/Runtime/API/HandTracker.cs Normal file
View File

@ -0,0 +1,267 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma warning disable CS0618 // Suppress deprecation warnings
using System;
using System.Runtime.InteropServices;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Represents a user's hand and the ability to track hand joints from it.
/// </summary>
#if UNITY_ANDROID
[Obsolete("Hand tracking on Android with the Mixed Reality OpenXR Plugin has been deprecated. " +
"For apps using Android hand tracking, we recommend transitioning to the OpenXR plugins from Unity and Meta.", false)]
#endif
public class HandTracker
{
/// <summary>
/// The user's left hand.
/// </summary>
public static HandTracker Left { get; } = new HandTracker(Handedness.Left);
/// <summary>
/// The user's right hand.
/// </summary>
public static HandTracker Right { get; } = new HandTracker(Handedness.Right);
private HandTrackingFeaturePlugin Feature = OpenXRFeaturePlugin<HandTrackingFeaturePlugin>.Feature;
private readonly Handedness m_handedness;
internal HandTracker(Handedness trackerHandedness)
{
m_handedness = trackerHandedness;
}
/// <summary>
/// The maximum number of hand joints that might be tracked.
/// </summary>
public const int JointCount = 26;
/// <summary>
/// Fills the passed-in array with current hand joint locations, if possible.
/// </summary>
/// <param name="frameTime">Specify the <see cref="FrameTime"/> to locate the hand joints.</param>
/// <param name="handJointLocations">An array of HandJointLocations, indexed according to the HandJoint enum.</param>
/// <returns>Returns true when the hand tracker is actively tracking the hands.
/// Returns false when the hand tracker is disabled or it's not properly set up.</returns>
/// <remarks>
/// The return value matches the XrHandTrackingDataSourceStateEXT::isActive value in XR_EXT_hand_tracking_data_source extension.
/// It returns true if the extension is not supported by OpenXR runtime because Unity cannot observe the hand tracker active state.
/// </remarks>
public bool TryLocateHandJoints(FrameTime frameTime, HandJointLocation[] handJointLocations)
{
if (handJointLocations.Length != JointCount)
{
Debug.LogError($"LocateJoints requires an array of size {JointCount}. You can use HandTracker.JointCount for this.");
return false;
}
return Feature.IsValidAndEnabled() && NativeLib.TryGetHandJointData(m_handedness, frameTime, handJointLocations);
}
/// <summary>
/// Get or set the motion range for this hand tracker.
/// </summary>
/// <remarks>
/// Setting the motion range will take effect immediately for subsequent <see cref="TryLocateHandJoints"/> function calls.
/// However, for Unity input system updates for hand joints, it will not take effect until next frame.
///
/// If <see cref="HandJointsMotionRange.ConformingToController"/> is used with an actual hand tracker,
/// <see cref="HandJointsMotionRange.Unobstructed"/> joints will still be returned.
/// It's only valid when a runtime supports hand joints when using a physical controller.
/// </remarks>
public HandJointsMotionRange MotionRange
{
get
{
return Feature.IsValidAndEnabled() && OpenXRContext.Current.IsSessionRunning
? NativeLib.GetHandJointsMotionRange(m_handedness)
: HandJointsMotionRange.Unobstructed;
}
set
{
if (Feature.IsValidAndEnabled())
{
NativeLib.SetHandJointsMotionRange(m_handedness, value);
}
}
}
}
/// <summary>
/// Represents locational data for a hand joint.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public readonly struct HandJointLocation
{
/// <summary>
/// Whether the corresponding hand joint is actively tracked.
/// </summary>
/// <remarks>If not actively tracked, the pose may be inferred or last-known but otherwise still meaningful.</remarks>
public bool IsTracked => Convert.ToBoolean(isTracked);
// bool isn't blittable, so marshal a byte across the P/Invoke layer instead
private readonly byte isTracked;
/// <summary>
/// The world-space pose of the corresponding hand joint.
/// </summary>
public Pose Pose { get; }
/// <summary>
/// The radius of the corresponding joint in units of meters.
/// </summary>
public float Radius { get; }
}
/// <summary>
/// Describes which hand the current hand tracker represents.
/// </summary>
public enum Handedness
{
/// <summary>
/// Represents the user's left hand.
/// </summary>
Left = 0,
/// <summary>
/// Represents the user's right hand.
/// </summary>
Right
}
/// <summary>
/// The supported tracked hand joints in OpenXR.
/// </summary>
/// <remarks>See https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrHandJointEXT for more information.</remarks>
public enum HandJoint
{
/// <summary>
/// The palm.
/// </summary>
Palm,
/// <summary>
/// The wrist.
/// </summary>
Wrist,
/// <summary>
/// The lowest joint of the thumb.
/// </summary>
ThumbMetacarpal,
/// <summary>
/// The second joint of the thumb.
/// </summary>
ThumbProximal,
/// <summary>
/// The joint nearest the tip of the thumb.
/// </summary>
ThumbDistal,
/// <summary>
/// The tip of the thumb.
/// </summary>
ThumbTip,
/// <summary>
/// The lowest joint of the index finger.
/// </summary>
IndexMetacarpal,
/// <summary>
/// The knuckle joint of the index finger.
/// </summary>
IndexProximal,
/// <summary>
/// The middle joint of the index finger.
/// </summary>
IndexIntermediate,
/// <summary>
/// The joint nearest the tip of the index finger.
/// </summary>
IndexDistal,
/// <summary>
/// The tip of the index finger.
/// </summary>
IndexTip,
/// <summary>
/// The lowest joint of the middle finger.
/// </summary>
MiddleMetacarpal,
/// <summary>
/// The proximal joint of the middle finger.
/// </summary>
MiddleProximal,
/// <summary>
/// The middle joint of the middle finger.
/// </summary>
MiddleIntermediate,
/// <summary>
/// The joint nearest the tip of the middle finger.
/// </summary>
MiddleDistal,
/// <summary>
/// The tip of the middle finger.
/// </summary>
MiddleTip,
/// <summary>
/// The lowest joint of the ring finger.
/// </summary>
RingMetacarpal,
/// <summary>
/// The knuckle of the ring finger.
/// </summary>
RingProximal,
/// <summary>
/// The middle joint of the ring finger.
/// </summary>
RingIntermediate,
/// <summary>
/// The joint nearest the tip of the ring finger.
/// </summary>
RingDistal,
/// <summary>
/// The tip of the ring finger.
/// </summary>
RingTip,
/// <summary>
/// The lowest joint of the little finger.
/// </summary>
LittleMetacarpal,
/// <summary>
/// The knuckle joint of the little finger.
/// </summary>
LittleProximal,
/// <summary>
/// The middle joint of the little finger.
/// </summary>
LittleIntermediate,
/// <summary>
/// The joint nearest the tip of the little finger.
/// </summary>
LittleDistal,
/// <summary>
/// The tip of the little finger.
/// </summary>
LittleTip,
}
/// <summary>
/// The requested hand joints' range of motion from a controller.
/// </summary>
/// <remarks>See https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsMotionRangeEXT for more information.</remarks>
public enum HandJointsMotionRange
{
/// <summary>
/// The range of motion of a human hand, without any obstructions.
/// </summary>
Unobstructed = 1,
/// <summary>
/// The range of motion of the hand joints taking into account any physical limits imposed by the controller itself.
/// </summary>
/// <remarks>
/// This will tend to be the most accurate pose compared to the user’s actual hand pose, but might not allow a closed fist for example.
/// </remarks>
ConformingToController = 2,
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/HandTracker.cs.meta Normal file
View File

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

151
com.microsoft.mixedreality.openxr/Runtime/API/MeshSettings.cs Normal file
View File

@ -0,0 +1,151 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using UnityEngine.XR;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// The type of mesh to request from the XRMeshSubsystem.
/// </summary>
public enum MeshType
{
///<summary>
/// A mesh intended for visualization.
///</summary>
Visual = 1,
///<summary>
/// A mesh intended for collision detection.
///</summary>
Collider = 2,
}
/// <summary>
/// The level of detail of visual mesh to request from the XRMeshSubsystem.
/// </summary>
/// <remarks>Has no effect on the collider mesh.</remarks>
public enum VisualMeshLevelOfDetail
{
/// <summary>
/// Coarse mesh level of detail with roughly 100 triangles per cubic meter.
/// </summary>
Coarse = 1,
/// <summary>
/// Medium mesh level of detail with roughly 400 triangles per cubic meter.
/// </summary>
Medium = 2,
/// <summary>
/// Fine mesh level of detail with roughly 2000 triangles per cubic meter.
/// </summary>
Fine = 3,
/// <summary>
/// Unlimited mesh level of detail with no guarantee as to the number of triangles per cubic meter.
/// </summary>
Unlimited = 4,
}
/// <summary>
/// The compute consistency to request from the XRMeshSubsystem.
/// </summary>
public enum MeshComputeConsistency
{
/// <summary>
/// A watertight, globally consistent snapshot, not limited to observable objects in
/// the scanned regions.
/// </summary>
ConsistentSnapshotComplete = 1,
/// <summary>
/// A non-watertight snapshot, limited to observable objects in the scanned regions.
/// The returned mesh may not be globally optimized for completeness, and therefore
/// may be returned faster in some scenarios.
/// </summary>
ConsistentSnapshotIncompleteFast = 2,
/// <summary>
/// A mesh optimized for lower-latency occlusion uses. The returned mesh may not be
/// globally consistent and might be adjusted piecewise independently.
/// </summary>
OcclusionOptimized = 3,
}
/// <summary>
/// Settings describing the quality and type of mesh to be provided.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct MeshComputeSettings
{
private MeshType meshType;
private VisualMeshLevelOfDetail visualMeshLevelOfDetail;
private MeshComputeConsistency meshComputeConsistency;
/// <summary>
/// Deprecated. The XRMeshSubsystem only supplies visual meshes. Use a <see cref="UnityEngine.MeshCollider"/> or the method <see cref="XRMeshSubsystem.GenerateMeshAsync(MeshId, UnityEngine.Mesh, UnityEngine.MeshCollider, MeshVertexAttributes, Action{MeshGenerationResult})"/> to get collider meshes as needed.
/// </summary>
/// <remarks>Defaults to <see cref="MeshType.Visual"/>.</remarks>
[Obsolete("Obsolete; only visual meshes are supplied through the mesh subsystem. Use a MeshCollider or the method XRMeshSubsystem.GenerateMeshAsync to get collider meshes as needed.")]
public MeshType MeshType
{
get => meshType != 0 ? meshType : MeshType.Visual;
set => meshType = MeshType.Visual;
}
/// <summary>
/// Get or set the level of detail of visual mesh to request from the XRMeshSubsystem.
/// </summary>
/// <remarks>Defaults to <see cref="VisualMeshLevelOfDetail.Coarse"/>.</remarks>
public VisualMeshLevelOfDetail VisualMeshLevelOfDetail
{
get => visualMeshLevelOfDetail != 0 ? visualMeshLevelOfDetail : VisualMeshLevelOfDetail.Coarse;
set => visualMeshLevelOfDetail = value;
}
/// <summary>
/// Get or set the compute consistency to request from the XRMeshSubsystem.
/// </summary>
/// <remarks>Defaults to <see cref="MeshComputeConsistency.OcclusionOptimized"/>.</remarks>
public MeshComputeConsistency MeshComputeConsistency
{
get => meshComputeConsistency != 0 ? meshComputeConsistency : MeshComputeConsistency.OcclusionOptimized;
set => meshComputeConsistency = value;
}
}
namespace ARSubsystems
{
/// <summary>
/// Additional functionality for the mesh subsystem.
/// </summary>
public static class MeshSubsystemExtensions
{
/// <summary>
/// Change the settings for future meshes given by the XRMeshSubsystem.
/// </summary>
/// <param name="subsystem">The <see cref="XRMeshSubsystem"/> to receive the settings</param>
/// <param name="settings">The mesh compute settings to be set.</param>
/// <returns>Returns true if the setting is successfully changed to the given value. Returns false otherwise. </returns>
[System.Obsolete("Obsolete and will be removed in future releases. Use MeshSettings.TrySetMeshComputeSettings() function instead.", true)]
public static bool TrySetMeshComputeSettings(this XRMeshSubsystem subsystem, MeshComputeSettings settings)
{
return InternalMeshSettings.TrySetMeshComputeSettings(settings);
}
}
}
/// <summary>
/// Static entry point for updating the mesh compute settings.
/// </summary>
public static class MeshSettings
{
/// <summary>
/// Change the settings for future meshes given by the XRMeshSubsystem.
/// </summary>
/// <param name="settings">The mesh compute settings to be set.</param>
/// <returns>Returns true if the setting is successfully changed to the given value. Returns false otherwise. </returns>
public static bool TrySetMeshComputeSettings(MeshComputeSettings settings)
{
return InternalMeshSettings.TrySetMeshComputeSettings(settings);
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/MeshSettings.cs.meta Normal file
View File

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

52
com.microsoft.mixedreality.openxr/Runtime/API/OpenXRContext.cs Normal file
View File

@ -0,0 +1,52 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Retrieve the current OpenXR instance, session handles and states.
/// </summary>
public class OpenXRContext
{
/// <summary>
/// Get the current OpenXR context.
/// </summary>
public static OpenXRContext Current { get; } = new OpenXRContext();
/// <summary>
/// The XrInstance handle, or 0 when instance is not initialized.
/// </summary>
public ulong Instance => OpenXRFeaturePluginManager.ActiveFeature != null ? OpenXRFeaturePluginManager.ActiveFeature.Instance : 0;
/// <summary>
/// The XrSystemId, or 0 when system is not available.
/// </summary>
public ulong SystemId => OpenXRFeaturePluginManager.ActiveFeature != null ? OpenXRFeaturePluginManager.ActiveFeature.SystemId : 0;
/// <summary>
/// The XrSession handle, or 0 when session is not created.
/// </summary>
public ulong Session => OpenXRFeaturePluginManager.ActiveFeature != null ? OpenXRFeaturePluginManager.ActiveFeature.Session : 0;
/// <summary>
/// Whether the current XrSession is running, i.e. when the frame loop is in progress.
/// </summary>
public bool IsSessionRunning => OpenXRFeaturePluginManager.ActiveFeature != null && OpenXRFeaturePluginManager.ActiveFeature.IsSessionRunning;
/// <summary>
/// An XrSpace handle to the reference space of the current Unity scene origin, or 0 when not available.
/// It's typically a LOCAL, a STAGE or an UNBOUNDED reference space handle when available.
/// </summary>
public ulong SceneOriginSpace => OpenXRFeaturePluginManager.ActiveFeature != null ? OpenXRFeaturePluginManager.ActiveFeature.SceneOriginSpace : 0;
/// <summary>
/// Get the function pointer to PFN_xrGetInstanceProcAddr that includes Unity OpenXR plugin and features overrides.
/// Returns 0 when XR is not loaded in Unity or xrInstance handle above is 0.
/// </summary>
public IntPtr PFN_xrGetInstanceProcAddr => OpenXRFeaturePlugin.PFN_xrGetInstanceProcAddr;
private OpenXRContext() { } // Should use static singleton `Current` property instead.
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/OpenXRContext.cs.meta Normal file
View File

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

48
com.microsoft.mixedreality.openxr/Runtime/API/OpenXRTime.cs Normal file
View File

@ -0,0 +1,48 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Provides methods to interact with OpenXR time, including retrieving the
/// predicting display times, and converting XR time to Query Performance Counter (QPC) time.
/// </summary>
public class OpenXRTime
{
/// <summary>
/// Get the current OpenXRTime.
/// </summary>
public static OpenXRTime Current => m_current;
/// <summary>
/// Retrieves the predicted display time for the current frame based on the specified frame timing.
/// </summary>
/// <remarks>
/// Will return 0 if called from Unity Editor.
/// </remarks>
/// <param name="frameTime">The time of a frame in pipelined rendering for which to retrieve the predicted display time. <see cref="FrameTime"/></param>
/// <returns>The predicted display time if available, otherwise 0</returns>
public long GetPredictedDisplayTimeInXrTime(FrameTime frameTime)
{
return NativeLib.GetPredictedDisplayTimeInXrTime(frameTime);
}
/// <summary>
/// Converts a time value from XR time to Query Performance Counter (QPC) time.
/// </summary>
/// <remarks>
/// Will return 0 if called from Unity Editor.
/// </remarks>
/// <param name="xrTime">The time in XR time units to be converted.</param>
/// <returns>The equivalent time in QPC units. If the conversion cannot be performed the function returns 0.</returns>
public long ConvertXrTimeToQpcTime(long xrTime)
{
return NativeLib.ConvertXrTimeToQpcTime(xrTime);
}
private OpenXRTime() { }// use static Current property instead.
private static readonly OpenXRTime m_current = new();
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/OpenXRTime.cs.meta Normal file
View File

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

43
com.microsoft.mixedreality.openxr/Runtime/API/PerceptionInterop.cs Normal file
View File

@ -0,0 +1,43 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Runtime.InteropServices;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Interop functions for Windows Perception APIs
/// </summary>
public static class PerceptionInterop
{
private static MixedRealityFeaturePlugin Feature => OpenXRFeaturePlugin<MixedRealityFeaturePlugin>.Feature;
/// <summary>
/// Get a COM wrapper object of a Windows.Perception.Spatial.SpatialCoordinateSystem object
/// located at the given pose in the current Unity scene.
/// If failed, the function returns nullptr.
/// The application should acquire a new one when session origin is changed or tracking mode is changed
/// by listening to XRInputSubsystem.trackingOriginUpdated and monitoring ARSession.currentTrackingMode.
/// </summary>
/// <param name="poseInScene">The pose of returned coordinate system in the current Unity scene.
/// If input Pose.identity, the returned coordinate system will be at the origin of the current Unity scene.</param>
/// <returns>Returns a COM wrapper C# object of type Windows.Perception.Spatial.SpatialCoordinateSystem.
/// Returns null if such coordinate system cannot be found at the moment.</returns>
public static object GetSceneCoordinateSystem(Pose poseInScene)
{
if (Feature.IsValidAndEnabled() && OpenXRContext.Current.IsSessionRunning)
{
IntPtr unknown = NativeLib.TryAcquireSceneCoordinateSystem(poseInScene);
if (unknown != IntPtr.Zero)
{
object result = Marshal.GetObjectForIUnknown(unknown);
Marshal.Release(unknown); // Balance the ref count because "feature.TryAcquire" increment it on return.
return result;
}
}
return null;
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/PerceptionInterop.cs.meta Normal file
View File

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

79
com.microsoft.mixedreality.openxr/Runtime/API/SelectKeywordRecognizer.cs Normal file
View File

@ -0,0 +1,79 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if UNITY_EDITOR || UNITY_STANDALONE || WINDOWS_UWP
using System;
using UnityEngine.Windows.Speech;
using static UnityEngine.Windows.Speech.PhraseRecognizer;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// A keyword recognizer listening to the "select" keyword localized in the system display language of HoloLens 2.
/// </summary>
/// <remarks>
/// <para>This class is only required by HoloLens 2 as the OS filters out the "select" keyword and thus
/// the Unity <see cref="KeywordRecognizer"/> does not fire events when the word is heard.</para>
/// <para>The API surface is made mostly identical to the Unity <see cref="KeywordRecognizer"/> for ease of use.</para>
/// <para>Like the Unity <see cref="KeywordRecognizer"/>, this class is only available under the UNITY_EDITOR || UNITY_STANDALONE || WINDOWS_UWP flags.
/// We recommend checking for those flags in the code using #if before referencing this class, especially when developing a cross-platform application.</para>
/// </remarks>
public sealed class SelectKeywordRecognizer : IDisposable
{
/// <summary>
/// Create a new SelectKeywordRecognizer.
/// </summary>
/// <remarks>
/// <para>Use <see cref="IsSupported"/> to check whether the recognizer is supported by the current platform / Unity version first before calling the constructor.
/// The constructor does the same check and will throw an exception if not supported.</para>
/// </remarks>
public SelectKeywordRecognizer()
{
m_provider = new SelectKeywordRecognizerProvider();
}
/// <summary>
/// Check whether the recognizer is supported by the current platform / Unity version
/// </summary>
public static bool IsSupported => SelectKeywordRecognizerProvider.IsSupported;
/// <summary>
/// Return whether the recognizer is running
/// </summary>
public bool IsRunning => m_provider.IsRunning;
/// <summary>
/// Event to be fired when the "select" keyword is recognized
/// </summary>
public event PhraseRecognizedDelegate OnPhraseRecognized
{
add
{
m_provider.OnPhraseRecognized += value;
}
remove
{
m_provider.OnPhraseRecognized -= value;
}
}
/// <summary>
/// Start the SelectKeywordRecognizer to listen for the select keyword
/// </summary>
public void Start() => m_provider.Start();
/// <summary>
/// Stop the SelectKeywordRecognizer from listening for the select keyword
/// </summary>
public void Stop() => m_provider.Stop();
/// <summary>
/// Dispose the resources used by SelectKeywordRecognizer
/// </summary>
public void Dispose() => m_provider.Dispose();
private SelectKeywordRecognizerProvider m_provider;
}
}
#endif // UNITY_EDITOR || UNITY_STANDALONE || WINDOWS_UWP

11
com.microsoft.mixedreality.openxr/Runtime/API/SelectKeywordRecognizer.cs.meta Normal file
View File

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

132
com.microsoft.mixedreality.openxr/Runtime/API/SpatialGraphNode.cs Normal file
View File

@ -0,0 +1,132 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// A spatial graph node represents a spatially tracked point provided by the driver.
/// </summary>
/// <remarks>
/// There are two types of spatial graph nodes: static and dynamic.
///
/// A static spatial graph node tracks the pose of a fixed location in the world.
/// The tracking of static nodes may slowly adjust the pose over time for better accuracy
/// but the pose is relatively stable in the short term, such as between rendering frames.
///
/// A dynamic spatial graph node tracks the pose of a physical object that moves
/// continuously relative to reference spaces. The pose of a dynamic spatial graph node
/// can be very different within the duration of a rendering frame.
/// </remarks>
public class SpatialGraphNode
{
/// <summary>
/// Creating a SpatialGraphNode with given static node id, or return null upon failure.
/// </summary>
/// <remarks>
/// The application typically obtains the Guid for the static node
/// from other spatial graph driver APIs. For example, a static node id
/// representing the tracking of a QR code can be obtained from HoloLens 2 QR code library.
/// </remarks>
/// <param name="id">A GUID represents a spatial graph static node.</param>
/// <returns>Returns either a valid SpatialGraphNode object if succeeded
/// or null if the given static node id cannot be found at the moment.</returns>
public static SpatialGraphNode FromStaticNodeId(System.Guid id)
{
if (OpenXRContext.Current.IsSessionRunning &&
NativeLib.TryCreateSpaceFromStaticNodeId(id, out ulong spaceId))
{
return new SpatialGraphNode()
{
Id = id,
m_spaceId = spaceId,
};
}
else
{
return null;
}
}
/// <summary>
/// Creating a SpatialGraphNode with given dynamic node id, or return null upon failure.
/// </summary>
/// <remarks>
/// The application typically obtains the Guid for the dynamic node
/// from other spatial graph driver APIs. For example, a dynamic node id
/// representing the tracking of the Photo and Video camera on HoloLens 2
/// can be obtained from media foundation APIs for the camera.
/// </remarks>
/// <param name="id">A GUID represents a spatial graph dynamic node.</param>
/// <returns>Returns either a valid SpatialGraphNode object if succeeded
/// or null if the given dynamic node id cannot be found at the moment.</returns>
public static SpatialGraphNode FromDynamicNodeId(System.Guid id)
{
if (OpenXRContext.Current.IsSessionRunning &&
NativeLib.TryCreateSpaceFromDynamicNodeId(id, out ulong spaceId))
{
return new SpatialGraphNode()
{
Id = id,
m_spaceId = spaceId,
};
}
else
{
return null;
}
}
/// <summary>
/// Get the Guid of the SpatialGraphNode
/// </summary>
public System.Guid Id { get; private set; } = System.Guid.Empty;
/// <summary>
/// Locate the SpatialGraphNode at the given frame time.
/// The returned pose is in the current Unity scene origin space.
/// </summary>
/// <returns>
/// Return true if the output pose is actively tracked, or return false indicating the node lost tracking.
/// </returns>
/// <remarks>
/// This function is typically used to locate the spatial graph node used in Unity's render pipeline
/// at either OnUpdate or OnBeforeRender callbacks. Providing the correct input frameTime
/// allows the runtime to provide correct motion prediction of the tracked node to the display time
/// of the current rendering frame.
/// </remarks>
/// <param name="frameTime">Specify the <see cref="FrameTime"/> to locate the spatial graph node.</param>
/// <param name="pose">Output the pose when the function returns true. Discard the value if the function returns false.</param>
public bool TryLocate(FrameTime frameTime, out Pose pose)
{
pose = Pose.identity;
return OpenXRContext.Current.IsSessionRunning && NativeLib.TryLocateSpatialGraphNodeSpace(m_spaceId, frameTime, out pose);
}
/// <summary>
/// Locate the SpatialGraphNode at the given QPC time.
/// The returned pose is in the current Unity scene origin space.
/// </summary>
/// <returns>
/// Return true if the output pose is actively tracked, or return false indicating the node lost tracking.
/// </returns>
/// <remarks>
/// This function is typically used to locate the spatial graph node using historical timestamp
/// obtained from other spatial graph APIs, for example the qpcTime of a IMFSample from media
/// foundation APIs representing the time when a Photo and Video camera captured the image.
/// Providing an accurate qpcTime from the camera sensor allows the runtime to locate precisely
/// where the dynamic node was tracked when the image was taken.
/// </remarks>
/// <param name="qpcTime">Specify the QPC (i.e. query performance counter) time to locate the spatial graph node.</param>
/// <param name="pose">Output the pose when the function returns true. Discard the value if the function returns false.</param>
public bool TryLocate(long qpcTime, out Pose pose)
{
pose = Pose.identity;
return OpenXRContext.Current.IsSessionRunning && NativeLib.TryLocateSpatialGraphNodeSpace(m_spaceId, qpcTime, out pose);
}
private SpatialGraphNode() { }
private ulong m_spaceId = 0;
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/SpatialGraphNode.cs.meta Normal file
View File

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

172
com.microsoft.mixedreality.openxr/Runtime/API/TrackingMapAPI.cs Normal file
View File

@ -0,0 +1,172 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Type of tracking maps
/// </summary>
public enum TrackingMapType : uint
{
/// <summary>
/// Default tracking map on HoloLens 2, shared between all applications.
/// </summary>
Shared = 0,
/// <summary>
/// New tracking environment private to application, which can be persisted
/// and restored with some limitations.
/// </summary>
ApplicationExclusive = 0x00000001
}
/// <summary>
/// TrackingMapManager class allows an application to opt into running in an Application-Exclusive tracking mode instead of default shared environment.
/// </summary>
/// <remarks>
/// <para>
/// Activating an Application-Exclusive tracking map creates a brand-new environment for the application, unencumbered by any Device Space
/// tracking inaccuracies as the result of degradation over time.
/// This is equivalent to using the "Remove All Holograms" command from Settings, but only applicable to the running application.
/// Holograms for all other applications (including the HoloLens Shell) remain intact and available as before.
/// Returning to the Shell or activating another application will return the HoloLens to the Device Shared tracking mode automatically.
/// </para>
/// <para>
/// When first entering the Application-Exclusive tracking mode, the calling application will be issued a unique identifier
/// that can be used to resume tracking the app-specific map in future sessions of the application
/// (like if the user switches away from the application and it is terminated in the background due to system resource constraints).
/// However, if the device simply goes to sleep or the user briefly interacts with the Shell,
/// the application will automatically resume in the Application-Exclusive tracking mode once it is reactivated (and all application state will remain available).
/// </para>
/// <para>
/// There are two limitations to be aware of when using the Application-Exclusive tracking mode:
/// </para>
/// <list type="number">
/// <item>
/// <description>Only a single Application-Exclusive tracking map can exist on the HoloLens at one time. If an application requests a new Application-Exclusive tracking mode,
/// then any previous Application-Exclusive tracking data would be erased and all SpatialAnchor objects (and attached holograms) would be lost,
/// even if the data was created by a completely different application using its own Application-Exclusive tracking mode.
/// Therefore, attempting to return to a previous Application-Exclusive map (by specifying the identifier received when this map was created)
/// may result in a return value indicating that the previous map was not found.
/// Applications must be prepared to handle the scenario where a previous Application-Exclusive tracking map is not available. </description>
/// </item>
/// <item>
/// <description> The disk storage available to the Application-Exclusive tracking mode is limited to one third of what is available for the Device Shared tracking mode,
/// although this is unlikely to be an issue for most users. When this limit is reached, HoloLens will begin erasing its least valuable tracking data,
/// which will eventually result in poorer tracking accuracy.
/// The smaller limit is still large enough to maintain good accuracy for house-sized environments and is unlikely to be a concern for most application scenarios.</description>
/// </item>
/// </list>
/// <para>Given these limitations, the target scenario for the Application-Exclusive tracking mode is for applications with high accuracy requirements that are task oriented,
/// where a task may be interrupted by the user returning the HoloLens Shell or the device going to sleep.
/// However, once the user's task is complete, nothing about the task (with respect to the 3D environment) needs to be saved and so can be erased.
/// </para>
/// <para>Examples:</para>
/// <list type="number">
/// <item>
/// <description> High-accuracy alignment of holograms to a real-world object, using QR codes to bootstrap the scenario. </description>
/// </item>
/// <item>
/// <description> Editing a 3D model with high-accuracy requirements when no 3D spatial persistence of the model needs to occur after the session ends. </description>
/// </item>
/// <item>
/// <description> Tracking in places that have a lot of environmental churn (like people moving around), which sometimes results in poorer tracking quality than more static environments. </description>
/// </item>
/// </list>
/// </remarks>
public class TrackingMapManager
{
private TrackingMapSubsystem m_trackingMapSubsystem;
private TrackingMapManager(TrackingMapSubsystem trackingMapSubsystem) {
m_trackingMapSubsystem = trackingMapSubsystem;
}
/// <summary>
/// Gets an instance of TrackingMapManager.
/// </summary>
/// <returns><c>Task&lt;TrackingMapManager&gt;</c> which is completed when the Tracking Map Manager is fully initialized.
/// The <c>Result</c> property of the task is a <c>TrackingMapManager</c> instance.</returns>
/// <remarks>Use <see cref="IsSupported(TrackingMapType)"><c>IsSupported</c></see> to check if the HoloLens 2
/// on which the application is currently executing supports Application-Exclusive maps.</remarks>
public static Task<TrackingMapManager> GetAsync()
{
Task<TrackingMapManager> result = Task.Run(() =>
{
TrackingMapSubsystem trackingMapSubsystem = TrackingMapSubsystem.TryCreateTrackingMapSubsystem();
return new TrackingMapManager(trackingMapSubsystem);
});
return result;
}
/// <summary>
/// Indicates if a tracking map type is supported
/// </summary>
/// <param name="trackingMapType">Tracking map type to check for support</param>
/// <returns>True if the tracking map type is supported.</returns>
/// <remarks>
/// TrackingMapType.Shared is always supported.
/// </remarks>
public bool IsSupported(TrackingMapType trackingMapType)
{
switch (trackingMapType)
{
case TrackingMapType.Shared:
return true;
case TrackingMapType.ApplicationExclusive:
return (m_trackingMapSubsystem != null) && m_trackingMapSubsystem.SupportsApplicationExclusiveMaps();
default:
return false;
}
}
/// <summary>
/// Indicates the active tracking map type.
/// </summary>
public TrackingMapType ActiveTrackingMapType
{
get => (m_trackingMapSubsystem != null) ? m_trackingMapSubsystem.ActiveTrackingMapType : TrackingMapType.Shared;
}
/// <summary>
/// Creates and activates a new application-exclusive map.
/// </summary>
/// <param name="existingMapId">Optional identifier to try reactivating a previously created map. If null is passed, a new map is created.
/// If a non empty guid map is passed, the tracking manager tries to load the corresponding map.
/// If the map cannot be found or loaded, a new map is created.</param>
/// <returns><c>Task&lt;Guid&gt;</c> which is completed when the system has created and activated an application-exclusive map.
/// The <c>Result</c> property contains the guid of the activated map. If it is equal to <c>existingMapId</c>, it means that the existing map has been reloaded.
/// If not, it means that a new map has been created.</returns>
/// <exception cref="System.InvalidOperationException">Thrown when the TrackingMapManager does not support application-exclusive Maps
/// or if a map change is already in progress.</exception>
/// <remarks>In order to take effect, the application must be the active, immersive 3D application.
/// <c>ActivateApplicationExclusiveMapAsync</c> should only be called once the application has started rendering its 3D user interface (and not, for example, when the application first starts).
/// </remarks>
public Task<Guid> ActivateApplicationExclusiveMapAsync(Guid? existingMapId = null)
{
if (m_trackingMapSubsystem == null) throw new InvalidOperationException("Feature not supported.");
Task<Guid> result = Task.Run(() =>
{
return m_trackingMapSubsystem.ActivateApplicationExclusiveMap(existingMapId);
});
return result;
}
/// <summary>
/// Leaves the current application-exclusive map and returns to the default shared map.
/// If the device was already in the default shared map, this method does nothing.
/// </summary>
/// <returns><c>Task</c> which is completed when the system has returned to the default map.</returns>
/// <exception cref="System.InvalidOperationException">Thrown when a map change is already in progress.</exception>
public Task ActivateSharedMapAsync()
{
if (m_trackingMapSubsystem == null) throw new InvalidOperationException("Feature not supported.");
Task result = Task.Run(() =>
{
m_trackingMapSubsystem.ActivateSharedMapAsync();
});
return result;
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/TrackingMapAPI.cs.meta Normal file
View File

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

166
com.microsoft.mixedreality.openxr/Runtime/API/ViewConfiguration.cs Normal file
View File

@ -0,0 +1,166 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using UnityEngine;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// A view configuration is a semantically meaningful set of one or more views for which an application can render images.
/// </summary>
public enum ViewConfigurationType
{
/// <summary>
/// A primary view configuration is a view configuration intended to be presented to the viewer interacting with the XR application.
/// </summary>
PrimaryStereo = 2,
/// <summary>
/// This first-person observer view configuration intended for a first-person view of the scene to be composed onto video frames
/// being captured from a camera attached to and moved with the primary display on the form factor, which is generally for viewing
/// on a 2D screen by an external observer. This first-person camera will be facing forward with roughly the same perspective as
/// the primary views, and so the application should render its view to show objects that surround the user and avoid rendering the user's body avatar.
/// </summary>
SecondaryMonoFirstPersonObserver = 1000054000
}
/// <summary>
/// Observe and manage a view configuration of the current XR session.
/// </summary>
public class ViewConfiguration
{
private static MixedRealityFeaturePlugin Feature => OpenXRFeaturePlugin<MixedRealityFeaturePlugin>.Feature;
internal readonly OpenXRViewConfiguration m_openxrViewConfiguration;
/// <summary>
/// Get all enabled view configurations when the XR session is started.
/// </summary>
public static IReadOnlyList<ViewConfiguration> EnabledViewConfigurations =>
Feature.IsValidAndEnabled() ? Feature.EnabledViewConfigurations : Array.Empty<ViewConfiguration>();
/// <summary>
/// Get the primary view configuration of the XR session.
/// </summary>
public static ViewConfiguration Primary => Feature.IsValidAndEnabled() ? Feature.PrimaryViewConfiguration : null;
internal ViewConfiguration(OpenXRViewConfiguration openxrViewConfiguration)
{
m_openxrViewConfiguration = openxrViewConfiguration;
}
/// <summary>
/// Get the view configuration type
/// </summary>
public ViewConfigurationType ViewConfigurationType => m_openxrViewConfiguration.ViewConfigurationType;
/// <summary>
/// Get whether or not this view configuration is active for the current frame.
/// If IsActive is false, the rendering into the view configuration will be ignored and not visible to user.
/// </summary>
public bool IsActive => m_openxrViewConfiguration.IsActive;
/// <summary>
/// Adjustment to stereo separation in meters for primary stereo view configuration.
/// The value will be ignored for mono or secondary view configurations.
/// </summary>
public float StereoSeparationAdjustment
{
set => m_openxrViewConfiguration.SetStereoSeparationAdjustment(value);
get => m_openxrViewConfiguration.StereoSeparationAdjustment;
}
/// <summary>
/// Get all supported reprojection modes for this view configuration.
/// </summary>
public IReadOnlyList<ReprojectionMode> SupportedReprojectionModes => m_openxrViewConfiguration.SupportedReprojectionModes;
/// <summary>
/// Set the reprojection settings for the view configuration that will be used for the current frame.
/// </summary>
/// <remarks>
/// The given setting only affects the current frame, and must be set for each frame to maintain the effect.
/// </remarks>
/// <param name="settings">The reprojection settings to be set.</param>
public void SetReprojectionSettings(ReprojectionSettings settings) => m_openxrViewConfiguration.SetReprojectionSettings(settings);
}
/// <summary>
/// The ReprojectionMode describes the reprojection mode of a projection composition layer.
/// </summary>
public enum ReprojectionMode
{
/// <summary>
/// Indicates the rendering may benefit from per-pixel depth reprojection.
/// This mode is typically used for world-locked content that should remain physically stationary as the user walks around.
/// </summary>
Depth = 1,
/// <summary>
/// Indicates the rendering may benefit from planar reprojection and the plane can be calculated from the corresponding depth information.
/// This mode works better when the application knows the content is mostly placed on a plane.
/// </summary>
PlanarFromDepth = 2,
/// <summary>
/// Indicates that the rendering may benefit from planar reprojection.
/// The application can customize the plane by ReprojectionSettings.
/// The app can also omit the plane override, indicating the runtime should use the default reprojection plane settings.
/// This mode works better when the application knows the content is mostly placed on a plane, or when it cannot afford to submit depth information.
/// </summary>
PlanarManual = 3,
/// <summary>
/// Indicates the layer should be stabilized only for changes to orientation, ignoring positional changes.
/// This mode works better for body-locked content that should follow the user as they walk around, such as 360-degree video.
/// </summary>
OrientationOnly = 4,
/// <summary>
/// Indicates the rendering should not be stabilized by the runtime.
/// </summary>
NoReprojection = -1
}
/// <summary>
/// The settings to control the reprojection of current rendering frame,
/// including the reprojection mode and optional stabilization plane override.
/// </summary>
public struct ReprojectionSettings
{
/// <summary>
/// The reprojection mode to be used with this view configuration. Overrides any reprojection mode
/// set in XRDisplaySubsystem. The default value is ReprojectionMode.Depth.
/// </summary>
public ReprojectionMode ReprojectionMode
{
get => m_reprojectionMode ?? ReprojectionMode.Depth;
set => m_reprojectionMode = value;
}
private ReprojectionMode? m_reprojectionMode;
/// <summary>
/// When the application is confident that overriding the reprojection plane can benefit hologram
/// stability, it can provide this override to further help the runtime fine tune the reprojection
/// details. This Vector3 describes the position of the focus plane represented in the Unity scene.
/// </summary>
public Vector3? ReprojectionPlaneOverridePosition;
/// <summary>
/// When the application is confident that overriding the reprojection plane can benefit hologram
/// stability, it can provide this override to further help the runtime fine tune the reprojection
/// details. This Vector3 is a unit vector describing the focus plane normal represented in the
/// Unity scene.
/// </summary>
public Vector3? ReprojectionPlaneOverrideNormal;
/// <summary>
/// When the application is confident that overriding the reprojection plane can benefit hologram
/// stability, it can provide this override to further help the runtime fine tune the reprojection
/// details. This Vector3 is a velocity of the position in the Unity scene, measured in meters per
/// second.
/// </summary>
public Vector3? ReprojectionPlaneOverrideVelocity;
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/ViewConfiguration.cs.meta Normal file
View File

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

149
com.microsoft.mixedreality.openxr/Runtime/API/XRAnchorStore.cs Normal file
View File

@ -0,0 +1,149 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine.XR.ARFoundation;
using UnityEngine.XR.ARSubsystems;
namespace Microsoft.MixedReality.OpenXR.ARFoundation
{
/// <summary>
/// Provides extension methods to use an ARAnchorManager to load an XRAnchorStore.
/// </summary>
public static class AnchorManagerExtensions
{
/// <summary>
/// Use this ARAnchorManager to load an XRAnchorStore.
/// </summary>
/// <returns>
/// A task which, when completed, will contain a valid XRAnchorStore, or will contain null if the anchor store could not be loaded.
/// </returns>
/// <param name="anchorManager">The <see cref="ARAnchorManager"/> to receive the loaded anchors from the store.</param>
/// <remarks>
/// The anchor subsystem might not be available if the XR session is not initialized at start up. In this case, the returned anchor store might be null.
/// Make sure to reload the anchor store after the XR session is initialized.
/// </remarks>
[System.Obsolete("Obsolete and will be removed in future releases. Use XRAnchorStore.LoadAnchorStoreAsync() function instead.", true)]
public static Task<XRAnchorStore> LoadAnchorStoreAsync(this ARAnchorManager anchorManager)
{
return XRAnchorStore.LoadAnchorStoreAsync(anchorManager.subsystem);
}
}
}
namespace Microsoft.MixedReality.OpenXR.ARSubsystems
{
/// <summary>
/// Provides extension methods to use an XRAnchorSubsystem to load an XRAnchorStore.
/// </summary>
public static class AnchorSubsystemExtensions
{
/// <summary>
/// Use this XRAnchorSubsystem to load an XRAnchorStore.
/// </summary>
/// <returns>
/// A task which, when completed, will contain a valid XRAnchorStore, or contain null if the anchor store could not be loaded.
/// </returns>
/// <param name="anchorSubsystem">The <see cref="XRAnchorSubsystem"/> to receive the loaded anchors from the store.</param>
/// <remarks>
/// The anchor subsystem might not be available if the XR session is not initialized at start up. In this case, the returned anchor store might be null.
/// Make sure to reload the anchor store after the XR session is initialized.
/// </remarks>
[System.Obsolete("Obsolete and will be removed in future releases. Use XRAnchorStore.LoadAnchorStoreAsync() function instead.", true)]
public static Task<XRAnchorStore> LoadAnchorStoreAsync(this XRAnchorSubsystem anchorSubsystem)
{
return XRAnchorStore.LoadAnchorStoreAsync(anchorSubsystem);
}
}
}
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Handles persisting anchors from the scene to the anchor store, loading anchors from the anchor store to the scene,
/// and managing anchors persisted in the anchor store.
/// </summary>
/// <remarks>
/// Persisting and unpersisting anchors from the anchor store does not affect their state in the Unity scene.
/// These operations only affect whether anchors will be available to load from the anchor store in the future.
/// </remarks>
public class XRAnchorStore
{
/// <summary>
/// The names of all persisted anchors available in this anchor store. Each of these persisted anchors can be loaded with <see cref="LoadAnchor"/>.
/// </summary>
public IReadOnlyList<string> PersistedAnchorNames => m_openxrAnchorStore.PersistedAnchorNames;
/// <summary>
/// Begin loading an anchor from the anchor store into the Unity scene.
/// On a future update of the ARAnchorManager or XRAnchorSubsystem, a new corresponding anchor will be created.
/// </summary>
/// <remarks>If the persisted anchor has already been loaded, the TrackableId for the existing anchor in the scene will be returned.</remarks>
/// <returns>The TrackableId which the anchor will use once it is created.</returns>
/// <param name="name">The name of the anchor to be loaded from the store.</param>
public TrackableId LoadAnchor(string name) => m_openxrAnchorStore.LoadAnchor(name);
/// <summary>
/// Persist an anchor in the anchor store, where it can be retrieved using <see cref="LoadAnchor"/>.
/// </summary>
/// <returns>True if the anchor was successfully persisted, false if an error occurred.</returns>
/// <param name="trackableId">The <see cref="TrackableId"/> of an anchor to be persisted in the store.</param>
/// <param name="name">A string to identify this anchor if it's successfully persisted in the store.</param>
public bool TryPersistAnchor(TrackableId trackableId, string name) => m_openxrAnchorStore.TryPersistAnchor(name, trackableId);
/// <summary>
/// Unpersist an anchor from the anchor store.
/// </summary>
/// <remarks>After an anchor is unpersisted from the store, it will still be valid and locatable in the current session.</remarks>
/// <param name="name">The name of the anchor to be unpersist from the store.</param>
public void UnpersistAnchor(string name) => m_openxrAnchorStore.UnpersistAnchor(name);
/// <summary>
/// Clear all persisted anchors from the anchor store.
/// </summary>
/// <remarks>After the anchors are cleared from the anchor store, they will still be valid and locatable in the current session.</remarks>
public void Clear() => m_openxrAnchorStore.Clear();
/// <summary>
/// This method will reload the anchor store. Use this if the head tracking map or anchors changed from outside the application.
/// </summary>
/// <remarks>All anchors must be removed from the scene prior to this call.</remarks>
/// <returns>True if the the reload succeeded, False if an error occurred.</returns>
public Task<bool> TryReloadAnchorStoreAsync() => m_openxrAnchorStore.TryReloadAnchorStoreAsync();
/// <summary>
/// Deprecated: Uses an existing <see cref="XRAnchorSubsystem"/> to load an XRAnchorStore.
/// </summary>
/// <returns>
/// A task which, when completed, will contain a valid XRAnchorStore, or contain null if the anchor store could not be loaded.
/// </returns>
/// <remarks>
/// The anchor subsystem might not be available if the XR session is not initialized at start up. In this case, the returned anchor store might be null.
/// Make sure to reload the anchor store after the XR session is initialized.
/// </remarks>
[Obsolete("This method is obsolete. Use the XRAnchorStore.LoadAnchorStoreAsync() function instead.", false)]
public static async Task<XRAnchorStore> LoadAsync(XRAnchorSubsystem anchorSubsystem) => await LoadAnchorStoreAsync(anchorSubsystem);
/// <returns>
/// A task which, when completed, will contain a valid XRAnchorStore, or contain null if the anchor store could not be loaded.
/// </returns>
/// <remarks>
/// The anchor subsystem might not be available if the XR session is not initialized at start up. In this case, the returned anchor store might be null.
/// Make sure to reload the anchor store after the XR session is initialized.
/// </remarks>
public static async Task<XRAnchorStore> LoadAnchorStoreAsync(XRAnchorSubsystem anchorSubsystem)
{
OpenXRAnchorStore openxrAnchorStore = await OpenXRAnchorStoreFactory.LoadAnchorStoreAsync(anchorSubsystem);
return openxrAnchorStore == null ? null : new XRAnchorStore(openxrAnchorStore);
}
internal XRAnchorStore(OpenXRAnchorStore openxrAnchorStore)
{
m_openxrAnchorStore = openxrAnchorStore;
}
private readonly OpenXRAnchorStore m_openxrAnchorStore;
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/XRAnchorStore.cs.meta Normal file
View File

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

110
com.microsoft.mixedreality.openxr/Runtime/API/XRAnchorTransferBatch.cs Normal file
View File

@ -0,0 +1,110 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using UnityEngine.XR.ARSubsystems;
namespace Microsoft.MixedReality.OpenXR
{
/// <summary>
/// Provides the ability to build up a batch of anchors and export them to a binary stream for transfer.
/// Typically on a second device, it then supports importing the transfer stream and loading in the original batch of anchors.
/// </summary>
/// <remarks>Use of this class requires an ARAnchorManager in the scene or some other manual management of an XRAnchorSubsystem.</remarks>
public class XRAnchorTransferBatch
{
/// <summary>
/// Constructor.
/// </summary>
public XRAnchorTransferBatch() : this(new AnchorTransferBatch()) { }
private XRAnchorTransferBatch(AnchorTransferBatch anchorTransferBatch)
{
m_anchorTransferBatch = anchorTransferBatch;
}
private readonly AnchorTransferBatch m_anchorTransferBatch;
/// <summary>
/// Provides a list of all identifiers currently mapped in this AnchorTransferBatch.
/// </summary>
public IReadOnlyList<string> AnchorNames => m_anchorTransferBatch.AnchorNames;
/// <summary>
/// Tries to convert and add an anchor with the corresponding <see cref="TrackableId"/> to an export list.
/// </summary>
/// <remarks>Call <see cref="ExportAsync"/> to get the transferable anchor data.</remarks>
/// <param name="trackableId">The <see cref="TrackableId"/> of an anchor to be exported.</param>
/// <param name="name">A string to identify this anchor upon import to another device.</param>
/// <returns>Whether the anchor was successfully converted into a Perception SpatialAnchor and added to the export list.</returns>
public bool AddAnchor(TrackableId trackableId, string name) => m_anchorTransferBatch.AddAnchor(trackableId, name);
/// <summary>
/// Removes an anchor from the transfer batch. Doesn't remove the existing Unity anchor, if one is present.
/// </summary>
/// <remarks>After an anchor is removed from the transfer batch, it will still be valid and locatable in the current session.</remarks>
/// <param name="name">The name of the anchor to be removed from the transfer batch.</param>
public void RemoveAnchor(string name) => m_anchorTransferBatch.RemoveAnchor(name);
/// <summary>
/// Removes all anchors from the transfer batch. Doesn't remove any existing Unity anchors, if present.
/// </summary>
/// <remarks>After the anchors are cleared from the transfer batch, they will still be valid and locatable in the current session.</remarks>
public void Clear() => m_anchorTransferBatch.Clear();
/// <summary>
/// Attempts to load a specified anchor from the transfer batch and reports it to Unity as an XRAnchor/ARAnchor.
/// </summary>
/// <remarks>It's then typically recommended to use an ARAnchorManager to access the resulting Unity anchor.</remarks>
/// <param name="name">The anchor's identifier from the transfer batch.</param>
/// <returns>The <see cref="TrackableId"/> of the resulting Unity anchor if successfully loaded, or TrackableId.invalidId if the given name is not found.</returns>
public TrackableId LoadAnchor(string name) => m_anchorTransferBatch.LoadAnchor(name);
/// <summary>
/// Attempts to load a specified anchor from the transfer batch and replace the specified Unity anchor's tracking data with the new anchor.
/// </summary>
/// <param name="name">The anchor's identifier from the transfer batch.</param>
/// <param name="trackableId">The existing Unity anchor to update to track this new spatial anchor.</param>
/// <returns>The <see cref="TrackableId"/> of the resulting Unity anchor (usually the same as the passed-in parameter) if successfully loaded,
/// or TrackableId.invalidId if the given name is not found.</returns>
public TrackableId LoadAndReplaceAnchor(string name, TrackableId trackableId) => m_anchorTransferBatch.LoadAndReplaceAnchor(name, trackableId);
/// <summary>
/// Exports any anchors added via <see cref="AddAnchor"/> into a Stream for transfer. Use <see cref="ImportAsync(Stream)"/> for reading this Stream.
/// </summary>
/// <param name="anchorTransferBatch">The anchor transfer batch instance to export from. This instance should have had anchors added before attempting export.</param>
/// <returns>A task which, when completed, will contain the exported array, or null if the export was unsuccessful.</returns>
public static async Task<Stream> ExportAsync(XRAnchorTransferBatch anchorTransferBatch)
{
MemoryStream output = new MemoryStream();
SerializationCompletionReason reason = await anchorTransferBatch.m_anchorTransferBatch.ExportAsync(output);
if (reason == SerializationCompletionReason.Succeeded)
{
return output;
}
return null;
}
/// <summary>
/// Imports the provided Stream into an <see cref="XRAnchorTransferBatch"/>.
/// </summary>
/// <param name="inputStream">The streamed data representing the result of a call to <see cref="ExportAsync(XRAnchorTransferBatch)"/>. This stream must be readable.</param>
/// <returns>A task which, when completed, will contain the resulting XRAnchorTransferBatch, or null if the import was unsuccessful.</returns>
public static async Task<XRAnchorTransferBatch> ImportAsync(Stream inputStream)
{
AnchorTransferBatch anchorTransfer = new AnchorTransferBatch();
SerializationCompletionReason reason = await anchorTransfer.ImportAsync(inputStream);
if (reason == SerializationCompletionReason.Succeeded)
{
return new XRAnchorTransferBatch(anchorTransfer);
}
return null;
}
}
}

11
com.microsoft.mixedreality.openxr/Runtime/API/XRAnchorTransferBatch.cs.meta Normal file
View File

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

12
com.microsoft.mixedreality.openxr/Runtime/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,12 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft.MixedReality.OpenXR.Editor")]
[assembly: InternalsVisibleTo("Microsoft.MixedReality.OpenXR.Tests")]
[assembly: InternalsVisibleTo("Microsoft.MixedReality.OpenXR.Internal")]
[assembly: InternalsVisibleTo("Microsoft.MixedReality.OpenXR.Internal.Editor")]
[assembly: AssemblyVersion("1.11.1")]

11
com.microsoft.mixedreality.openxr/Runtime/AssemblyInfo.cs.meta Normal file
View File

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

8
com.microsoft.mixedreality.openxr/Runtime/FeaturePlugins.meta Normal file
View File

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

104
com.microsoft.mixedreality.openxr/Runtime/FeaturePlugins/AppRemotingPlugin.cs Normal file
View File

@ -0,0 +1,104 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System;
using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.XR.OpenXR.Features;
#endif
namespace Microsoft.MixedReality.OpenXR.Remoting
{
#if UNITY_EDITOR
[OpenXRFeature(UiName = featureName,
BuildTargetGroups = new[] { BuildTargetGroup.Standalone, BuildTargetGroup.WSA },
Company = "Microsoft",
Desc = "Feature to enable " + featureName + ".",
DocumentationLink = "https://aka.ms/openxr-unity-app-remoting",
OpenxrExtensionStrings = requestedExtensions,
Category = FeatureCategory.Feature,
Required = false,
Priority = -100, // hookup before other plugins so it affects json before GetProcAddr.
FeatureId = featureId,
Version = "1.11.1")]
#endif
[RequiresNativePluginDLLs]
internal class AppRemotingPlugin : OpenXRFeaturePlugin<AppRemotingPlugin>
{
internal const string featureId = "com.microsoft.openxr.feature.appremoting";
internal const string featureName = "Holographic Remoting remote app";
private const string requestedExtensions = "XR_MSFT_holographic_remoting XR_MSFT_holographic_remoting_speech";
private OpenXRRuntimeRestartHandler m_restartHandler = null;
protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
{
if (enabled)
{
AppRemotingSubsystem.GetCurrent().TryEnableRemotingOverride();
}
return base.HookGetInstanceProcAddr(func);
}
protected override void OnSubsystemCreate()
{
base.OnSubsystemCreate();
if (enabled && m_restartHandler == null)
{
m_restartHandler = new OpenXRRuntimeRestartHandler(this, skipRestart: true, skipQuitApp: true);
}
else if (!enabled && m_restartHandler != null)
{
m_restartHandler.Dispose();
m_restartHandler = null;
}
}
protected override void OnInstanceDestroy(ulong instance)
{
if (enabled)
{
AppRemotingSubsystem.GetCurrent().ResetRemotingOverride();
}
Debug.Log($"[AppRemotingPlugin] OnInstanceDestroy, remotingState was {AppRemotingSubsystem.AppRemotingState}.");
base.OnInstanceDestroy(instance);
}
protected override void OnSystemChange(ulong systemId)
{
base.OnSystemChange(systemId);
if (systemId != 0)
{
Debug.Log($"[AppRemotingPlugin] OnSystemChange, systemId = {systemId}");
if(enabled)
{
AppRemotingSubsystem.GetCurrent().InitializeRemoting();
}
}
}
protected override void OnSessionStateChange(int oldState, int newState)
{
if ((XrSessionState)newState == XrSessionState.LossPending)
{
if(enabled)
{
AppRemotingSubsystem.GetCurrent().OnSessionLossPending();
}
}
}
#if UNITY_EDITOR
protected override void GetValidationChecks(System.Collections.Generic.List<ValidationRule> results, BuildTargetGroup targetGroup)
{
AppRemotingValidator.GetValidationChecks(this, results, targetGroup);
}
#endif
}
}

Some files were not shown because too many files have changed in this diff Show More