pass args to boundary system

Author: David Kline (ANALOG)

Assets/MixedRealityToolkit.Services/BoundarySystem/MixedRealityBoundarySystem.cs

@@ -4,6 +4,7 @@
 using Microsoft.MixedReality.Toolkit.Core.Definitions.BoundarySystem;
 using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
 using Microsoft.MixedReality.Toolkit.Core.EventDatum.Boundary;
+using Microsoft.MixedReality.Toolkit.Core.Interfaces;
 using Microsoft.MixedReality.Toolkit.Core.Interfaces.BoundarySystem;
 using Microsoft.MixedReality.Toolkit.Core.Services;
 using Microsoft.MixedReality.Toolkit.Core.Utilities;
@@ -19,8 +20,18 @@ namespace Microsoft.MixedReality.Toolkit.Services.BoundarySystem
     /// <summary>
     /// The Boundary system controls the presentation and display of the users boundary in a scene.
     /// </summary>
-    public class MixedRealityBoundarySystem : BaseEventSystem, IMixedRealityBoundarySystem
+    public class MixedRealityBoundarySystem : BaseCoreSystem, IMixedRealityBoundarySystem
     {
+        public MixedRealityBoundarySystem(
+            IMixedRealityServiceRegistrar registrar,
+            MixedRealityBoundaryVisualizationProfile profile,
+            Transform playspace,
+            ExperienceScale scale) : base(registrar, profile)
+        {
+            Scale = scale;
+            Playspace = playspace;
+        }
+
         #region IMixedRealityService Implementation
 
         private BoundaryEventData boundaryEventData = null;
@@ -30,25 +41,27 @@ public override void Initialize()
         {
             if (!Application.isPlaying) { return; }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return; }
+
             boundaryEventData = new BoundaryEventData(EventSystem.current);
 
-            Scale = MixedRealityToolkit.Instance.ActiveProfile.TargetExperienceScale;
-            BoundaryHeight = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.BoundaryHeight;
+            BoundaryHeight = profile.BoundaryHeight;
 
             SetTrackingSpace();
             CalculateBoundaryBounds();
             Boundary.visible = true;
 
-            ShowFloor = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.ShowFloor;
-            FloorPhysicsLayer = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.FloorPhysicsLayer;
-            ShowPlayArea = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.ShowPlayArea;
-            PlayAreaPhysicsLayer = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.PlayAreaPhysicsLayer;
-            ShowTrackedArea = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.ShowTrackedArea;
-            TrackedAreaPhysicsLayer = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.TrackedAreaPhysicsLayer;
-            ShowBoundaryWalls = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.ShowBoundaryWalls;
-            BoundaryWallsPhysicsLayer = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.BoundaryWallsPhysicsLayer;
-            ShowBoundaryCeiling = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.ShowBoundaryCeiling;
-            CeilingPhysicsLayer = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.CeilingPhysicsLayer;
+            ShowFloor = profile.ShowFloor;
+            FloorPhysicsLayer = profile.FloorPhysicsLayer;
+            ShowPlayArea = profile.ShowPlayArea;
+            PlayAreaPhysicsLayer = profile.PlayAreaPhysicsLayer;
+            ShowTrackedArea = profile.ShowTrackedArea;
+            TrackedAreaPhysicsLayer = profile.TrackedAreaPhysicsLayer;
+            ShowBoundaryWalls = profile.ShowBoundaryWalls;
+            BoundaryWallsPhysicsLayer = profile.BoundaryWallsPhysicsLayer;
+            ShowBoundaryCeiling = profile.ShowBoundaryCeiling;
+            CeilingPhysicsLayer = profile.CeilingPhysicsLayer;
 
             if (ShowFloor)
             {
@@ -245,6 +258,13 @@ public int GetHashCode(object obj)
 
         #region IMixedRealityBoundarySystem Implementation
 
+        /// <summary>
+        /// The transform of the playspace scene object. We use this transform to parent
+        /// boundary visualizations that teleport with the user and to perform calculations
+        /// to ensure proper alignment with the world.
+        /// </summary>
+        private Transform Playspace = null;
+
         /// <summary>
         /// The thickness of three dimensional generated boundary objects.
         /// </summary>
@@ -273,7 +293,7 @@ private GameObject BoundaryVisualizationParent
                 }
 
                 var visualizationParent = new GameObject("Boundary System Visualizations");
-                visualizationParent.transform.parent = MixedRealityToolkit.Instance.MixedRealityPlayspace;
+                visualizationParent.transform.parent = Playspace;
                 return boundaryVisualizationParent = visualizationParent;
             }
         }
@@ -570,7 +590,8 @@ public bool Contains(Vector3 location, Boundary.Type boundaryType = Boundary.Typ
             }
 
             // Handle the user teleporting (boundary moves with them).
-            location = MixedRealityToolkit.Instance.MixedRealityPlayspace.InverseTransformPoint(location);
+            // todo: update...
+            location = Playspace.InverseTransformPoint(location);
 
             if (FloorHeight.Value > location.y ||
                 BoundaryHeight < location.y)
@@ -613,7 +634,8 @@ public bool TryGetRectangularBoundsParams(out Vector2 center, out float angle, o
             }
 
             // Handle the user teleporting (boundary moves with them).
-            Vector3 transformedCenter = MixedRealityToolkit.Instance.MixedRealityPlayspace.TransformPoint(
+            // todo: update...
+            Vector3 transformedCenter = Playspace.TransformPoint(
                 new Vector3(rectangularBounds.Center.x, 0f, rectangularBounds.Center.y));
 
             center = new Vector2(transformedCenter.x, transformedCenter.z);
@@ -633,24 +655,28 @@ public GameObject GetFloorVisualization()
                 return currentFloorObject;
             }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return null; }
+
             if (!FloorHeight.HasValue)
             {
                 // We were unable to locate the floor.
                 return null;
             }
 
-            Vector2 floorScale = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.FloorScale;
+            Vector2 floorScale = profile.FloorScale;
 
             // Render the floor.
             currentFloorObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
             currentFloorObject.name = "Boundary System Floor";
             currentFloorObject.transform.localScale = new Vector3(floorScale.x, boundaryObjectThickness, floorScale.y);
+            // todo: update...
             currentFloorObject.transform.Translate(new Vector3(
-                MixedRealityToolkit.Instance.MixedRealityPlayspace.position.x,
+                Playspace.position.x,
                 FloorHeight.Value - (currentFloorObject.transform.localScale.y * 0.5f),
-                MixedRealityToolkit.Instance.MixedRealityPlayspace.position.z));
+                Playspace.position.z));
             currentFloorObject.layer = FloorPhysicsLayer;
-            currentFloorObject.GetComponent<Renderer>().sharedMaterial = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.FloorMaterial;
+            currentFloorObject.GetComponent<Renderer>().sharedMaterial = profile.FloorMaterial;
 
             return currentFloorObject;
         }
@@ -665,6 +691,9 @@ public GameObject GetPlayAreaVisualization()
                 return currentPlayAreaObject;
             }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return null; }
+
             // Get the rectangular bounds.
             Vector2 center;
             float angle;
@@ -690,7 +719,7 @@ public GameObject GetPlayAreaVisualization()
             currentPlayAreaObject.transform.Translate(new Vector3(center.x, boundaryObjectRenderOffset, center.y));
             currentPlayAreaObject.transform.Rotate(new Vector3(90, -angle, 0));
             currentPlayAreaObject.transform.localScale = new Vector3(width, height, 1.0f);
-            currentPlayAreaObject.GetComponent<Renderer>().sharedMaterial = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.PlayAreaMaterial;
+            currentPlayAreaObject.GetComponent<Renderer>().sharedMaterial = profile.PlayAreaMaterial;
 
             currentPlayAreaObject.transform.parent = BoundaryVisualizationParent.transform;
 
@@ -707,6 +736,9 @@ public GameObject GetTrackedAreaVisualization()
                 return currentTrackedAreaObject;
             }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return null; }
+
             if (Bounds.Length == 0)
             {
                 // If we do not have boundary edges, we cannot render them.
@@ -726,16 +758,17 @@ public GameObject GetTrackedAreaVisualization()
             currentTrackedAreaObject = new GameObject("Tracked Area");
             currentTrackedAreaObject.layer = ignoreRaycastLayerValue;
             currentTrackedAreaObject.AddComponent<LineRenderer>();
+            // todo: update...
             currentTrackedAreaObject.transform.Translate(new Vector3(
-                MixedRealityToolkit.Instance.MixedRealityPlayspace.position.x,
+                Playspace.position.x,
                 boundaryObjectRenderOffset,
-                MixedRealityToolkit.Instance.MixedRealityPlayspace.position.z));
+                Playspace.position.z));
             currentPlayAreaObject.layer = TrackedAreaPhysicsLayer;
 
             // Configure the renderer properties.
             float lineWidth = 0.01f;
             LineRenderer lineRenderer = currentTrackedAreaObject.GetComponent<LineRenderer>();
-            lineRenderer.sharedMaterial = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.TrackedAreaMaterial;
+            lineRenderer.sharedMaterial = profile.TrackedAreaMaterial;
             lineRenderer.useWorldSpace = false;
             lineRenderer.startWidth = lineWidth;
             lineRenderer.endWidth = lineWidth;
@@ -757,6 +790,9 @@ public GameObject GetBoundaryWallVisualization()
                 return currentBoundaryWallObject;
             }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return null; }
+
             if (!FloorHeight.HasValue)
             {
                 // We need a floor on which to place the walls.
@@ -778,7 +814,7 @@ public GameObject GetBoundaryWallVisualization()
             {
                 GameObject wall = GameObject.CreatePrimitive(PrimitiveType.Cube);
                 wall.name = $"Wall {i}";
-                wall.GetComponent<Renderer>().sharedMaterial = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.BoundaryWallMaterial;
+                wall.GetComponent<Renderer>().sharedMaterial = profile.BoundaryWallMaterial;
                 wall.transform.localScale = new Vector3((Bounds[i].PointB - Bounds[i].PointA).magnitude, BoundaryHeight, wallDepth);
                 wall.layer = ignoreRaycastLayerValue;
 
@@ -806,6 +842,9 @@ public GameObject GetBoundaryCeilingVisualization()
                 return currentCeilingObject;
             }
 
+            MixedRealityBoundaryVisualizationProfile profile = ConfigurationProfile as MixedRealityBoundaryVisualizationProfile;
+            if (profile == null) { return null; }
+
             if (Bounds.Length == 0)
             {
                 // If we do not have boundary edges, we cannot render a ceiling.
@@ -830,7 +869,7 @@ public GameObject GetBoundaryCeilingVisualization()
                 boundaryBoundingBox.center.x,
                 BoundaryHeight + (currentCeilingObject.transform.localScale.y * 0.5f),
                 boundaryBoundingBox.center.z));
-            currentCeilingObject.GetComponent<Renderer>().sharedMaterial = MixedRealityToolkit.Instance.ActiveProfile.BoundaryVisualizationProfile.BoundaryCeilingMaterial;
+            currentCeilingObject.GetComponent<Renderer>().sharedMaterial = profile.BoundaryCeilingMaterial;
             currentCeilingObject.layer = CeilingPhysicsLayer;
             currentCeilingObject.transform.parent = BoundaryVisualizationParent.transform;
 

…alityToolkit/Providers/BaseCoreSystem.cs …ealityToolkit/Services/BaseCoreSystem.csAssets/MixedRealityToolkit/Providers/BaseCoreSystem.cs renamed to Assets/MixedRealityToolkit/Services/BaseCoreSystem.cs Assets/MixedRealityToolkit/Providers/BaseCoreSystem.cs renamed to Assets/MixedRealityToolkit/Services/BaseCoreSystem.cs

@@ -384,7 +384,9 @@ private void InitializeServiceLocator()
             // If the Boundary system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsBoundarySystemEnabled)
             {
-                if (!RegisterService<IMixedRealityBoundarySystem>(ActiveProfile.BoundarySystemSystemType) || BoundarySystem == null)
+                object[] args = { this, ActiveProfile.BoundaryVisualizationProfile, Instance.MixedRealityPlayspace, ActiveProfile.TargetExperienceScale };
+
+                if (!RegisterService<IMixedRealityBoundarySystem>(ActiveProfile.BoundarySystemSystemType, args : args) || BoundarySystem == null)
                 {
                     Debug.LogError("Failed to start the Boundary System!");
                 }