Merge pull request #2402 from davidkline-ms/vNext-Boundary

vNext: Implement MixedRealityBoundaryManager and Profile

Author: keveleigh

Assets/MixedRealityToolkit-SDK/Profiles/DefaultMixedRealityConfigurationProfile.asset

@@ -11,6 +11,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 41718b8e5d86c37409b7ce6847fa00a3, type: 3}
   m_Name: DefaultMixedRealityConfigurationProfile
   m_EditorClassIdentifier: 
+  targetExperienceScale: 3
   enableCameraProfile: 1
   cameraProfile: {fileID: 11400000, guid: b9a895b32a50a7f45b1e4da728d50741, type: 2}
   enableInputSystem: 1
@@ -25,3 +26,8 @@ MonoBehaviour:
   enableControllerProfiles: 1
   controllersProfile: {fileID: 11400000, guid: 4319257468937c74ebb69e41792d60c5, type: 2}
   enableBoundarySystem: 1
+  boundarySystemType:
+    reference: Microsoft.MixedReality.Toolkit.Internal.Managers.MixedRealityBoundaryManager,
+      Microsoft.MixedReality.Toolkit
+  boundaryHeight: 3
+  enablePlatformBoundaryRendering: 1

Assets/MixedRealityToolkit/_Core/Boundary/MixedRealityBoundarySystem.cs

@@ -2,7 +2,13 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using Microsoft.MixedReality.Toolkit.Internal.Definitions;
+using Microsoft.MixedReality.Toolkit.Internal.Definitions.Utilities;
 using Microsoft.MixedReality.Toolkit.Internal.Interfaces;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.XR;
+using UnityEngine.XR;
 
 namespace Microsoft.MixedReality.Toolkit.Internal.Managers
 {
@@ -11,45 +17,130 @@ namespace Microsoft.MixedReality.Toolkit.Internal.Managers
     /// </summary>
     public class MixedRealityBoundaryManager : BaseManager, IMixedRealityBoundarySystem
     {
+        /// <inheritdoc/>
+        public ExperienceScale Scale { get; set; } = ExperienceScale.Room;
+
+        /// <inheritdoc/>
+        public float BoundaryHeight { get; set; } = 3.0f;
+
+        /// <inheritdoc/>
+        public bool EnablePlatformBoundaryRendering { get; set; } = true;
+
+        /// <inheritdoc/>
+        public Bounds OutscribedVolume { get; private set; } = new Bounds();
+
+        /// <inheritdoc/>
+        public Bounds InscribedVolume { get; private set; } = new Bounds();
+
         /// <summary>
         /// MixedRealityBoundaryManager constructor
         /// </summary>
         public MixedRealityBoundaryManager()
         {
-            // TODO define any constructor requirements
+            Scale = MixedRealityManager.Instance.ActiveProfile.TargetExperienceScale;
+            BoundaryHeight = MixedRealityManager.Instance.ActiveProfile.BoundaryHeight;
+            EnablePlatformBoundaryRendering = MixedRealityManager.Instance.ActiveProfile.EnablePlatformBoundaryRendering;
         }
 
-        /// <summary>
-        /// The initialize function is used to setup the manager once created.
-        /// This method is called once all managers have been registered in the Mixed Reality Manager.
-        /// </summary>
+        /// <inheritdoc/>
         public override void Initialize()
         {
-            // TODO Initialize stuff 
+            base.Initialize();
+            InitializeInternal();
         }
 
         /// <summary>
-        /// Optional ProfileUpdate function to allow reconfiguration when the active configuration profile of the Mixed Reality Manager is replaced
+        /// Performs initialization tasks for the BoundaryManager.
         /// </summary>
+        private void InitializeInternal()
+        {
+            SetTrackingSpace();
+            CalculateBoundaryBounds();
+            SetPlatformBoundaryVisibility();
+        }
+
+        /// <inheritdoc/>
         public override void Reset()
         {
-            // TODO React to profile change
+            base.Reset();
+            InitializeInternal();
         }
 
         /// <summary>
-        /// Optional Update function to perform per-frame updates of the manager
+        /// Retrieves the boundary geometry and creates the boundary and inscribed playspace volumes.
         /// </summary>
-        public override void Update()
+        private void CalculateBoundaryBounds()
         {
-            // TODO Update stuff 
+            if (XRDevice.GetTrackingSpaceType() != TrackingSpaceType.RoomScale)
+            {
+                // Boundaries are supported for Room Scale experiences only.
+                return;
+            }
+
+            OutscribedVolume = new Bounds();
+
+            // Get the boundary geometry.
+            List<Vector3> boundaryGeometry = new List<Vector3>(0);
+            if (Boundary.TryGetGeometry(boundaryGeometry))
+            {
+                for (int i = 0; i < boundaryGeometry.Count; i++)
+                {
+                    OutscribedVolume.Encapsulate(boundaryGeometry[i]);
+                }
+
+                // todo: CreateInscribedBounds()
+
+                // Set the "ceiling" of the space using the configured height.
+                OutscribedVolume.Encapsulate(new Vector3(0f, BoundaryHeight, 0f));
+            }
+        }
+
+        /// <summary>
+        /// Updates the <see cref="TrackingSpaceType"/> on the XR device.
+        /// </summary>
+        private void SetTrackingSpace()
+        {
+            TrackingSpaceType trackingSpace;
+
+            // In current versions of Unity, there are two types of tracking spaces. For boundaries, if the scale
+            // is not Room or Standing, it currently maps to TrackingSpaceType.Stationary.
+            switch (Scale)
+            {
+                case ExperienceScale.Standing:
+                case ExperienceScale.Room:
+                    trackingSpace = TrackingSpaceType.RoomScale;
+                    break;
+
+                case ExperienceScale.OrientationOnly:
+                case ExperienceScale.Seated:
+                case ExperienceScale.World:
+                    trackingSpace = TrackingSpaceType.Stationary;
+                    break;
+
+                default:
+                    trackingSpace = TrackingSpaceType.Stationary;
+                    Debug.LogWarning("Unknown / unsupported ExperienceScale. Defaulting to Stationary tracking space.");
+                    break;
+            }
+
+            XRDevice.SetTrackingSpaceType(trackingSpace);
         }
 
         /// <summary>
-        /// Optional Destroy function to perform cleanup of the manager before the Mixed Reality Manager is destroyed
+        /// Sets the property indicating if the boundary should be rendered by the platform.
         /// </summary>
-        public override void Destroy()
+        /// <remarks>
+        /// Not all platforms support specifying whether or not to render the playspace boundary.
+        /// For platforms without boundary rendering control, the default behavior will be unchanged 
+        /// regardless of the value provided.
+        /// </remarks>
+        private void SetPlatformBoundaryVisibility()
         {
-            // TODO Destroy stuff 
+            if (Boundary.configured)
+            {
+                // This value cannot be configured on Windows Mixed Reality. Automatic boundary rendering is performed.
+                Boundary.visible = EnablePlatformBoundaryRendering;
+            }
         }
     }
 }

Assets/MixedRealityToolkit/_Core/Definitions/MixedRealityConfigurationProfile.cs

@@ -43,6 +43,19 @@ public class MixedRealityConfigurationProfile : ScriptableObject, ISerialization
 
         #region Mixed Reality Manager configurable properties
 
+        [SerializeField]
+        [Tooltip("The scale of the Mixed Reality experience.")]
+        private ExperienceScale targetExperienceScale = ExperienceScale.Room;
+
+        /// <summary>
+        /// The desired the scale of the experience.
+        /// </summary>
+        public ExperienceScale TargetExperienceScale
+        {
+            get { return targetExperienceScale; }
+            set { targetExperienceScale = value; }
+        }
+
         [SerializeField]
         [Tooltip("Enable the Camera Profile on Startup")]
         private bool enableCameraProfile = false;
@@ -84,9 +97,7 @@ public bool EnableInputSystem
         {
             get
             {
-                return inputSystemType != null &&
-                       inputSystemType?.Type != null &&
-                       inputActionsProfile != null &&
+                return inputActionsProfile != null &&
                        enableInputSystem;
             }
             private set { enableInputSystem = value; }
@@ -176,12 +187,62 @@ public MixedRealityControllerMappingProfile ControllersProfile
         private bool enableBoundarySystem = false;
 
         /// <summary>
-        /// Enable and configure the Boundary component on the Mixed Reality Camera
+        /// Enable and configure the boundary system.
         /// </summary>
         public bool EnableBoundarySystem
         {
-            get { return enableBoundarySystem; }
-            private set { enableBoundarySystem = value; }
+            get
+            {
+                return boundarySystemType?.Type != null &&
+                       enableBoundarySystem;
+            }
+            private set { enableInputSystem = value; }
+        }
+
+        [SerializeField]
+        [Tooltip("Boundary System Class to instantiate at runtime.")]
+        [Implements(typeof(IMixedRealityBoundarySystem), TypeGrouping.ByNamespaceFlat)]
+        private SystemType boundarySystemType;
+
+        /// <summary>
+        /// Boundary System Script File to instantiate at runtime.
+        /// </summary>
+        public SystemType BoundarySystemSystemType
+        {
+            get { return boundarySystemType; }
+            private set { boundarySystemType = value; }
+        }
+
+        [SerializeField]
+        [Tooltip("The approximate height of the playspace, in meters.")]
+        private float boundaryHeight = 3.0f;
+
+        /// <summary>
+        /// The approximate height of the playspace, in meters.
+        /// </summary>
+        /// <remarks>
+        /// The BoundaryHeight property is used to create a three dimensional volume for the playspace.
+        /// </remarks>
+        public float BoundaryHeight
+        {
+            get { return boundaryHeight; }
+            set { boundaryHeight = value; }
+        }
+
+        [SerializeField]
+        [Tooltip("Instruct the platform whether or not to render the playspace boundary. Note: not all platforms support configuring this option.")]
+        private bool enablePlatformBoundaryRendering = true;
+
+        /// <summary>
+        /// Instruct the platform whether or not to render the playspace boundary.
+        /// </summary>
+        /// <remarks>
+        /// Not all platforms support the EnablePlatformBoundaryRendering property.
+        /// </remarks>
+        public bool EnablePlatformBoundaryRendering
+        {
+            get { return enablePlatformBoundaryRendering; }
+            set { enablePlatformBoundaryRendering = value; }
         }
 
         #endregion Mixed Reality Manager configurable properties

Assets/MixedRealityToolkit/_Core/Definitions/Utilities/ExperienceScale.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace Microsoft.MixedReality.Toolkit.Internal.Definitions.Utilities
+{
+    /// <summary>
+    /// The ExperienceScale identifies the environment for which the experience is designed.
+    /// </summary>
+    [System.Serializable]
+    public enum ExperienceScale
+    {
+        /// <summary>
+        /// An experience which utilizes only the headset orientantion and is gravity aligned. The coordinate system origin is at head level.
+        /// </summary>
+        OrientationOnly = 0,
+        /// <summary>
+        /// An experience designed for seated use. The coordinate system origin is at head level.
+        /// </summary>
+        Seated,
+        /// <summary>
+        /// An experience designed for stationary standing use. The coordinate system origin is at floor level.
+        /// </summary>
+        Standing,
+        /// <summary>
+        /// An experience designed to support movement thoughtout a room. The coordinate system origin is at floor level.
+        /// </summary>
+        Room,
+        /// <summary>
+        /// An experience designed to utilize and move through the physical world. The coordinate system origin is at head level.
+        /// </summary>
+        World
+    }
+}