Support for Holographic Remoting (#213)

* Make XR Anchor Manager startup async so it can wait for XR startup if necessary.

Also, some minor no-op changes to suppress warnings.

* Expand remoting support to pre-Unity2020.

* Bump patch version to 1.5.2.

* Port ARF fix back to ARF2019.

* Make AlignSubtree component smarter about auto-save and load.

* Update publishing files to v1.5.2.

Author: fast-slow-still

Assets/WorldLocking.ASA.Examples/Scripts/ScreenSpacer.cs

@@ -40,7 +40,7 @@ private void CaptureLocalPose()
         }
 
         [SerializeField]
-        private MeshFilter meshFilter;
+        private MeshFilter meshFilter = null;
 
         private void Awake()
         {

Assets/WorldLocking.Core/Scripts/ARF/AnchorManagerARF.cs

@@ -76,10 +76,16 @@ public override Pose AnchorFromSpongy
 
         protected override float TrackingStartDelayTime { get { return SpongyAnchorARF.TrackingStartDelayTime; } }
 
-        public static AnchorManagerARF TryCreate(IPlugin plugin, IHeadPoseTracker headTracker, 
+        public static async Task<AnchorManagerARF> TryCreate(IPlugin plugin, IHeadPoseTracker headTracker, 
             GameObject arSessionSource,
             GameObject arSessionOriginSource)
         {
+            bool xrRunning = await CheckXRRunning();
+            if (!xrRunning)
+            {
+                Debug.LogError($"Error checking that XR is up and running.");
+                return null;
+            }
             if (arSessionSource == null)
             {
                 Debug.LogError("Trying to create an AR Foundation anchor manager with null session source holder GameObject.");
@@ -116,6 +122,28 @@ public static AnchorManagerARF TryCreate(IPlugin plugin, IHeadPoseTracker headTr
             return anchorManager;
         }
 
+                /// <summary>
+        /// Wait to make sure XR is up and running before proceeding. This is important when using Holographic Remoting,
+        /// during which the delay can be significant.
+        /// </summary>
+        /// <returns></returns>
+        private static async Task<bool> CheckXRRunning()
+        {
+#if WLT_XR_MANAGEMENT_PRESENT
+            DebugLogSetup($"F={Time.frameCount} checking that XR is running.");
+            // Wait for XR initialization before initializing the anchor subsystem to ensure that any pending Remoting connection has been established first.
+            while (UnityEngine.XR.Management.XRGeneralSettings.Instance == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.activeLoader == null)
+            {
+                DebugLogSetup($"F={Time.frameCount} waiting on XR startup.");
+                await Task.Yield();
+            }
+            DebugLogSetup($"F={Time.frameCount} XR is running.");
+#endif // WLT_XR_MANAGEMENT_PRESENT
+            return true;
+        }
+
         /// <summary>
         /// Set up an anchor manager.
         /// </summary>

Assets/WorldLocking.Core/Scripts/ARF/AnchorManagerARF_2019.cs

@@ -54,10 +54,16 @@ public override Pose AnchorFromSpongy
 
         protected override float TrackingStartDelayTime { get { return SpongyAnchorARF.TrackingStartDelayTime; } }
 
-        public static AnchorManagerARF TryCreate(IPlugin plugin, IHeadPoseTracker headTracker, 
+        public static async Task<AnchorManagerARF> TryCreate(IPlugin plugin, IHeadPoseTracker headTracker, 
             GameObject arSessionSource,
             GameObject arSessionOriginSource)
         {
+            bool xrRunning = await CheckXRRunning();
+            if (!xrRunning)
+            {
+                Debug.LogError($"Error checking that XR is up and running.");
+                return null;
+            }
             if (arSessionSource == null)
             {
                 Debug.LogError("Trying to create an AR Foundation anchor manager with null session source holder GameObject.");
@@ -94,6 +100,29 @@ public static AnchorManagerARF TryCreate(IPlugin plugin, IHeadPoseTracker headTr
             return anchorManager;
         }
 
+        /// <summary>
+        /// Wait to make sure XR is up and running before proceeding. This is important when using Holographic Remoting,
+        /// during which the delay can be significant.
+        /// </summary>
+        /// <returns></returns>
+        private static async Task<bool> CheckXRRunning()
+        {
+#if WLT_XR_MANAGEMENT_PRESENT
+            DebugLogSetup($"F={Time.frameCount} checking that XR is running.");
+            // Wait for XR initialization before initializing the anchor subsystem to ensure that any pending Remoting connection has been established first.
+            while (UnityEngine.XR.Management.XRGeneralSettings.Instance == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.activeLoader == null)
+            {
+                DebugLogSetup($"F={Time.frameCount} waiting on XR startup.");
+                await Task.Yield();
+            }
+            DebugLogSetup($"F={Time.frameCount} XR is running.");
+#endif // WLT_XR_MANAGEMENT_PRESENT
+            return true;
+        }
+
+
         /// <summary>
         /// Set up an anchor manager.
         /// </summary>

Assets/WorldLocking.Core/Scripts/ARF/SpongyAnchorARF_2019.cs

@@ -81,10 +81,16 @@ public override Pose SpongyPose
         {
             get
             {
-                Pose frozenFromAnchor = transform.GetGlobalPose();
-                Pose spongyFromFrozen = WorldLockingManager.GetInstance().SpongyFromFrozen;
-                Pose spongyFromAnchor = spongyFromFrozen.Multiply(frozenFromAnchor);
-                return spongyFromAnchor;
+                if (WorldLockingManager.GetInstance().ApplyAdjustment)
+                {
+                    // Global space is frozen space. Transform into spongy space.
+                    Pose frozenFromAnchor = transform.GetGlobalPose();
+                    Pose spongyFromFrozen = WorldLockingManager.GetInstance().SpongyFromFrozen;
+                    Pose spongyFromAnchor = spongyFromFrozen.Multiply(frozenFromAnchor);
+                    return spongyFromAnchor;
+                }
+                // Global space is spongy space. Return global pose.
+                return transform.GetGlobalPose();
             }
         }
 

Assets/WorldLocking.Core/Scripts/AlignSubtree.cs

@@ -150,7 +150,7 @@ private static string FixExtension(string name, string ext)
         /// <summary>
         /// Encapsulate all prerequisites for successful load here.
         /// </summary>
-        private bool ReadyToAutoLoad { get { return needAutoLoad && (alignmentManager != null); } }
+        private bool ReadyToAutoLoad { get { return needAutoLoad && (alignmentManager != null) && SupportsPersistence; } }
 
         /// <summary>
         /// Encapsulate all prerequisites for successful save here.
@@ -159,7 +159,26 @@ private static string FixExtension(string name, string ext)
         /// This does not check to see if a save is actually warranted, that check is elsewhere. This
         /// just check whether, if it would be good to save, the system is ready to.
         /// </remarks>
-        private bool ReadyToAutoSave { get { return !needAutoLoad && autoSave; } }
+        private bool ReadyToAutoSave { get { return !needAutoLoad && autoSave && SupportsPersistence; } }
+
+        /// <summary>
+        /// Check if persistence is supported, to avoid useless (and confusing) spacepin auto-save and load when anchors can't be saved and loaded.
+        /// </summary>
+        /// <remarks>
+        /// This is done on demand, because at start the final anchor manager may or may not have been created yet.
+        /// </remarks>
+        private bool SupportsPersistence
+        {
+            get
+            {
+                var wltMgr = WorldLockingManager.GetInstance();
+                if (wltMgr.AnchorManager != null && wltMgr.AnchorManager.SupportsPersistence)
+                {
+                    return true;
+                }
+                return false;
+            }
+        }
 #endregion Internal members
 
 #region Public APIs

Assets/WorldLocking.Core/Scripts/FragmentManager.cs

@@ -78,7 +78,11 @@ public FragmentManager(IPlugin plugin)
         public void Update(bool autoRefreeze, bool autoMerge)
         {
             CurrentFragmentId = plugin.GetMostSignificantFragmentId();
-            Debug.Assert(CurrentFragmentId.IsKnown(), "Update shouldn't be called with no active fragment.");
+            Debug.Assert(CurrentFragmentId.IsKnown(), $"F={Time.frameCount} - Update shouldn't be called with no active fragment.");
+            if (!CurrentFragmentId.IsKnown())
+            {
+                return;
+            }
             EnsureFragment(CurrentFragmentId);
 
             if (plugin.Metrics.RefitRefreezeIndicated && autoRefreeze)

Assets/WorldLocking.Core/Scripts/WorldLockingManager.cs

@@ -303,7 +303,8 @@ public Pose PlayspaceFromSpongy
         /// <summary>
         /// Keep track of whether one-time initializations have been performed yet.
         /// </summary>
-        private bool hasBeenStarted = false;
+        private enum InitializationState { Uninitialized, Starting, Running };
+        private InitializationState initializationState = InitializationState.Uninitialized;
 
         /// <summary>
         /// A handle of the class offering the optional feature of periodically logging the FrozenWorld engine state to disk
@@ -385,9 +386,9 @@ public void SetContext(WorldLockingContext context)
             shared = context.SharedSettings;
             DiagnosticRecordings.SharedSettings = context.DiagnosticsSettings;
 
-            if (!hasBeenStarted)
+            if (initializationState == InitializationState.Uninitialized)
             {
-                OneTimeStartUp();
+                ResetAnchorManager();
             }
 
             ApplyNewSettings();
@@ -399,9 +400,11 @@ public void SetContext(WorldLockingContext context)
         /// Perform any initialization only appropriate once. This is called after
         /// giving the caller a chance to change settings.
         /// </summary>
-        private void OneTimeStartUp()
+        public async void ResetAnchorManager()
         {
-            anchorManager = SelectAnchorManager(Plugin, headPoseTracker);
+            initializationState = InitializationState.Starting;
+
+            anchorManager = await SelectAnchorManager(Plugin, headPoseTracker);
 
             if (AutoLoad)
             {
@@ -412,23 +415,23 @@ private void OneTimeStartUp()
                 Reset();
             }
 
-            hasBeenStarted = true;
+            initializationState = InitializationState.Running;
         }
 
-        private IAnchorManager SelectAnchorManager(IPlugin plugin, IHeadPoseTracker headTracker)
+        private async Task<IAnchorManager> SelectAnchorManager(IPlugin plugin, IHeadPoseTracker headTracker)
         {
             DebugLogSetup($"Select {shared.anchorSettings.anchorSubsystem} anchor manager.");
             if (AnchorManager != null)
             {
-                DebugLogSetup("Creating new anchormanager, but have old one. Reseting it before replacing.");
+                DebugLogSetup("Creating new anchor manager, but have old one. Reseting it before replacing.");
                 AnchorManager.Reset();
             }
             var anchorSettings = shared.anchorSettings;
 #if WLT_ARFOUNDATION_PRESENT
             if (anchorSettings.anchorSubsystem == AnchorSettings.AnchorSubsystem.ARFoundation)
             {
                 DebugLogSetup($"Trying to create ARF anchor manager on {anchorSettings.ARSessionSource.name} and {anchorSettings.ARSessionOriginSource.name}");
-                AnchorManagerARF arfAnchorManager = AnchorManagerARF.TryCreate(plugin, headTracker,
+                AnchorManagerARF arfAnchorManager = await AnchorManagerARF.TryCreate(plugin, headTracker,
                     anchorSettings.ARSessionSource, anchorSettings.ARSessionOriginSource);
                 if (arfAnchorManager != null)
                 {
@@ -442,7 +445,7 @@ private IAnchorManager SelectAnchorManager(IPlugin plugin, IHeadPoseTracker head
             if (anchorSettings.anchorSubsystem == AnchorSettings.AnchorSubsystem.XRSDK)
             {
                 DebugLogSetup($"Trying to create XR anchor manager");
-                AnchorManagerXR xrAnchorManager = AnchorManagerXR.TryCreate(plugin, headTracker);
+                AnchorManagerXR xrAnchorManager = await AnchorManagerXR.TryCreate(plugin, headTracker);
                 if (xrAnchorManager != null)
                 {
                     DebugLogSetup("Success creating XR anchor manager");
@@ -483,6 +486,8 @@ private IAnchorManager SelectAnchorManager(IPlugin plugin, IHeadPoseTracker head
             }
             AnchorManagerNull nullAnchorManager = AnchorManagerNull.TryCreate(plugin, headTracker);
             Debug.Assert(nullAnchorManager != null, "Creation of Null anchor manager should never fail.");
+            /// No-op await here to suppress warnings if no anchor manager system which requires asynchronous startup is compiled in.
+            await Task.CompletedTask;
             return nullAnchorManager;
         }
 
@@ -566,6 +571,11 @@ private void Update()
         {
             ErrorStatus = "";
 
+            if (initializationState != InitializationState.Running)
+            {
+                ErrorStatus = $"Init: F={Time.frameCount} - {initializationState}";
+                return;
+            }
             if (hasPendingLoadTask)
             {
                 ErrorStatus = "pending background load task";

Assets/WorldLocking.Core/Scripts/XR/AnchorManagerXR.cs

@@ -8,6 +8,7 @@
 #endif // WLT_XR_PERSISTENCE
 
 //#define WLT_EXTRA_LOGGING
+#define WLT_LOG_SETUP
 
 #if WLT_DISABLE_LOGGING
 #undef WLT_EXTRA_LOGGING
@@ -63,8 +64,14 @@ public partial class AnchorManagerXR : AnchorManager
 
         private readonly Dictionary<TrackableId, SpongyAnchorXR> anchorsByTrackableId = new Dictionary<TrackableId, SpongyAnchorXR>();
 
-        public static AnchorManagerXR TryCreate(IPlugin plugin, IHeadPoseTracker headTracker)
+        public static async Task<AnchorManagerXR> TryCreate(IPlugin plugin, IHeadPoseTracker headTracker)
         {
+            bool xrRunning = await CheckXRRunning();
+            if (!xrRunning)
+            {
+                return null;
+            }
+
             /// Try to find an XRAnchorManager (to be XRAnchorManager) here. 
             /// If we fail that,
             ///     give up. 
@@ -88,6 +95,23 @@ public static AnchorManagerXR TryCreate(IPlugin plugin, IHeadPoseTracker headTra
             return anchorManager;
         }
 
+        private static async Task<bool> CheckXRRunning()
+        {
+#if WLT_XR_MANAGEMENT_PRESENT
+            DebugLogSetup($"F={Time.frameCount} checking that XR is running.");
+            // Wait for XR initialization before initializing the anchor subsystem to ensure that any pending Remoting connection has been established first.
+            while (UnityEngine.XR.Management.XRGeneralSettings.Instance == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager == null ||
+                   UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.activeLoader == null)
+            {
+                DebugLogSetup($"F={Time.frameCount} waiting on XR startup.");
+                await Task.Yield();
+            }
+            DebugLogSetup($"F={Time.frameCount} XR is running.");
+#endif // WLT_XR_MANAGEMENT_PRESENT
+            return true;
+        }
+
         /// <summary>
         /// Find the correct AnchorManager for this session.
         /// </summary>
@@ -128,7 +152,7 @@ private static XRAnchorSubsystem FindAnchorManager()
                     {
                         activeSubsystem = sub;
                         ++numFound;
-                        DebugLogSetup($"Start changed anchor subsystem {sub.subsystemDescriptor.id} to running.");
+                        DebugLogSetup($"Start changed anchor subsystem [{sub.subsystemDescriptor.id}] to running.");
                     }
                 }
             }
@@ -172,7 +196,7 @@ private static XRSessionSubsystem FindSessionSubsystem()
                     {
                         activeSession = session;
                         ++numFound;
-                        DebugLogSetup($"Start changed session {session.subsystemDescriptor.id} to running.");
+                        DebugLogSetup($"Start changed session [{session.subsystemDescriptor.id}] to running.");
                     }
                 }
             }