ARDK UPM 3.12.0

Author: jrsNiantic

Runtime/ARFoundation/Overrides/LocationAR/ARLocationManager.cs

@@ -97,9 +97,6 @@ public int MaxLocationTrackingCount
         private ARSessionState _lastARSessionState = ARSessionState.None;
         private ARLocationTrackedEventArgs? _lastLocationTrackedEventArgs;
 
-        // Workaround for frequent anchor pose updates
-        private Pose _lastAnchorPose;
-
         protected override void OnEnable()
         {
             // This will invoke OnBeforeStart and then start the subsystem. Put any initialization logic
@@ -330,7 +327,6 @@ private void HandleARPersistentAnchorStateChanged(
 
                     var args = new ARLocationTrackedEventArgs(arLocation, tracking, reason, anchor.trackingConfidence);
                     InvokeTrackingStateChangedWithARSessionState(args, _lastARSessionState);
-                    _lastAnchorPose = anchor.PredictedPose;
                     _lastLocationTrackedEventArgs = args;
                 }
                 else
@@ -361,7 +357,6 @@ private void HandleARPersistentAnchorStateChanged(
                     // Note: You could call arLocation.gameObject.SetActive(false) in locationTrackingStateChanged event if you wanted to de-activate gameObject when tracking is lost
                     var args = new ARLocationTrackedEventArgs(arLocation, false, reason, anchor.trackingConfidence);
                     InvokeTrackingStateChangedWithARSessionState(args, _lastARSessionState);
-                    _lastAnchorPose = anchor.PredictedPose;
                     _lastLocationTrackedEventArgs = args;
                 }
             }
@@ -376,25 +371,6 @@ private void InvokeTrackingStateChangedWithARSessionState(ARLocationTrackedEvent
                 return;
             }
 
-            // If we've previously localized, check that there is new info to report
-            // This is a temporary workaround for native firing multiple identical updates
-            if (_lastLocationTrackedEventArgs.HasValue)
-            {
-                var locationTransform = args.Value.ARLocation.transform;
-                var allInfoIdentical = _lastAnchorPose.position ==
-                    locationTransform.position &&
-                    _lastAnchorPose.rotation == locationTransform.rotation &&
-                    args.Value.Tracking == _lastLocationTrackedEventArgs.Value.Tracking &&
-                    args.Value.TrackingStateReason ==
-                    _lastLocationTrackedEventArgs.Value.TrackingStateReason &&
-                    sessionState == _lastARSessionState;
-
-                if (allInfoIdentical)
-                {
-                    return;
-                }
-            }
-
             var newArgs = args.Value;
 
             // If ARSessionState is not SessionTracking, fire the event as not tracking

Runtime/ARFoundation/Overrides/Occlusion/Extension/Features/Stabilization.cs

@@ -50,12 +50,16 @@ protected override string Keyword
         private CommandBuffer _meshObserverCommandBuffer;
 
         // Additional resources
-        private Texture2D _defaultNonLinearDepthTexture;
+        private Texture2D _defaultMeshDepthTexture;
         public RenderTexture MeshDepthTexture { get; private set; }
 
         // URP render pass
 #if MODULE_URP_ENABLED
         private OffScreenBlitPass _renderPass;
+
+        private RTHandle _meshDepthTextureHandle;
+
+        private RTHandleSystem _rtHandleSystem;
 #endif
 
         /// <summary>
@@ -143,6 +147,10 @@ public bool Configure(
             _renderPass = new OffScreenBlitPass(
                 name: "Lightship Occlusion Extension (Stabilization)",
                 renderPassEvent: RenderPassEvent.AfterRendering);
+
+            _rtHandleSystem = new RTHandleSystem();
+            _rtHandleSystem.Initialize(KFusedDepthWidth, KFusedDepthHeight);
+            _meshDepthTextureHandle = _rtHandleSystem.Alloc(MeshDepthTexture);
 #endif
             return true;
         }
@@ -156,16 +164,20 @@ protected override void OnMaterialAttach(Material mat)
 
             // The default texture bound to the fused depth property on the material.
             // It lets every pixel pass through until the real depth texture is ready to use.
-            if (_defaultNonLinearDepthTexture == null)
+            if (_defaultMeshDepthTexture == null)
             {
-                var val = OcclusionExtensionUtils.IsDepthReversed() ? 0.0f : 1.0f;
-                _defaultNonLinearDepthTexture = new Texture2D(2, 2, TextureFormat.RFloat, mipChain: false);
-                _defaultNonLinearDepthTexture.SetPixelData(new[] {val, val, val, val}, 0);
-                _defaultNonLinearDepthTexture.Apply(false);
+                // The mesh depth texture contains linear eye depth
+                // Here we default to 1000 meters, because we don't
+                // have access to the camera's far clip plane.
+                const float val = 1000.0f;
+
+                _defaultMeshDepthTexture = new Texture2D(2, 2, TextureFormat.RFloat, mipChain: false);
+                _defaultMeshDepthTexture.SetPixelData(new[] {val, val, val, val}, 0);
+                _defaultMeshDepthTexture.Apply(false);
             }
 
             // Bind pass-through texture by default
-            mat.SetTexture(ShaderProperties.FusedDepthTextureId, _defaultNonLinearDepthTexture);
+            mat.SetTexture(ShaderProperties.FusedDepthTextureId, _defaultMeshDepthTexture);
         }
 
         protected override void OnMaterialDetach(Material mat)
@@ -252,16 +264,23 @@ protected override void OnReleaseResources()
                 Object.Destroy(_meshObserverMaterialInternal);
             }
 
-            if (_defaultNonLinearDepthTexture != null)
+            if (_defaultMeshDepthTexture != null)
             {
-                Object.Destroy(_defaultNonLinearDepthTexture);
+                Object.Destroy(_defaultMeshDepthTexture);
             }
 
             if (MeshDepthTexture != null)
             {
                 Object.Destroy(MeshDepthTexture);
             }
 
+#if MODULE_URP_ENABLED
+            if( _meshDepthTextureHandle != null )
+            {
+                _meshDepthTextureHandle.Release();
+            }
+#endif
+
             _meshObserverCommandBuffer?.Dispose();
         }
 
@@ -315,7 +334,7 @@ private void EnqueueUniversalRenderPass(ScriptableRenderContext context, Camera
             if (cam == _meshObserverCamera)
             {
                 // Configure the render pass
-                _renderPass.Setup(Material, MeshDepthTexture);
+                _renderPass.Setup(Material, MeshDepthTexture, _meshDepthTextureHandle);
 
                 // Enqueue the render pass
                 cam.GetUniversalAdditionalCameraData().scriptableRenderer.EnqueuePass(_renderPass);

Runtime/ARFoundation/Overrides/Occlusion/Extension/OcclusionComponentDeployment.cs

@@ -7,6 +7,7 @@
 using Niantic.Lightship.AR.Utilities.Logging;
 using Niantic.Lightship.AR.XRSubsystems;
 using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Serialization;
 using UnityEngine.XR.ARFoundation;
 using UnityEngine.XR.ARSubsystems;
@@ -160,11 +161,15 @@ protected override bool OnAddRenderComponent(RenderComponent component)
                 // The occlusion stabilization feature requires the mesh manager
                 case Stabilization occlusionStabilization:
                 {
-#if NIANTIC_LIGHTSHIP_ML2_ENABLED
-                    // TODO(ahegedus): Unlock this feature for ML2
-                    Log.Error("Occlusion stabilization is not yet supported on ML2.");
-                    return false;
-#endif
+                    // https://docs.unity3d.com/2022.3/Documentation/Manual/SL-CameraDepthTexture.html
+                    // Direct3D 11+ (Windows), OpenGL 3+ (Mac/Linux), OpenGL ES 3.0+ (iOS), Metal (iOS)
+                    // and popular consoles support depth textures.
+                    if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan)
+                    {
+                        Log.Error("Occlusion stabilization is not yet supported on Vulkan devices.");
+                        return false;
+                    }
+
                     if (_meshManager == null)
                     {
                         // Attempt to find the mesh manager

Runtime/ARFoundation/Overrides/Occlusion/LightshipFusedDepthCamera.cs

@@ -36,6 +36,11 @@ internal Material Material
         /// </summary>
         internal RenderTexture GpuTexture { get; private set; }
 
+#if MODULE_URP_ENABLED
+        internal RTHandle GpuTextureHandle {get; private set;}
+        internal RTHandleSystem RtHandleSystem {get; private set;}
+#endif
+
         // Resources
         private Camera _camera;
         private Material _internalMaterial;
@@ -104,6 +109,12 @@ private void Awake()
 
             GpuTexture.Create();
 
+#if MODULE_URP_ENABLED
+            RtHandleSystem = new RTHandleSystem();
+            RtHandleSystem.Initialize(1024, 1024);
+            GpuTextureHandle = RtHandleSystem.Alloc(GpuTexture);
+#endif
+
             // Allocate a camera
             _camera = gameObject.AddComponent<Camera>();
 
@@ -127,6 +138,13 @@ private void OnDestroy()
             {
                 Destroy(GpuTexture);
             }
+
+#if MODULE_URP_ENABLED
+            if( GpuTextureHandle != null)
+            {
+                GpuTextureHandle.Release();
+            }
+#endif
         }
 
 #if !MODULE_URP_ENABLED
@@ -160,7 +178,7 @@ private void OnBeginCameraRendering(ScriptableRenderContext context, Camera cam)
             if (cam == _camera)
             {
                 // Configure the render pass
-                _renderPass.Setup(Material, GpuTexture);
+                _renderPass.Setup(Material, GpuTexture, GpuTextureHandle);
 
                 // Enqueue the render pass
                 cam.GetUniversalAdditionalCameraData().scriptableRenderer.EnqueuePass(_renderPass);

Runtime/ARFoundation/Overrides/Occlusion/URP/OffScreenBlitPass.cs

@@ -15,6 +15,7 @@ internal sealed class OffScreenBlitPass : FullScreenBlitPass
     {
         // The target render texture
         private RenderTexture _target;
+        private RTHandle _targetHandle;
 
         public OffScreenBlitPass(string name, RenderPassEvent renderPassEvent)
             : base(name, renderPassEvent) { }
@@ -24,18 +25,19 @@ public OffScreenBlitPass(string name, RenderPassEvent renderPassEvent)
         /// </summary>
         /// <param name="material">The material used to render the image.</param>
         /// <param name="target">The target to render the image to.</param>
-        public void Setup(Material material, RenderTexture target)
+        public void Setup(Material material, RenderTexture target, RTHandle targetHandle)
         {
             SetMaterial(material);
             _target = target;
+            _targetHandle = targetHandle;
         }
 
         public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
         {
             base.Configure(cmd, cameraTextureDescriptor);
-
+            
             // TODO(ahegedus): Make this use RTHandle instead of RenderTexture
-            ConfigureTarget(_target);
+            ConfigureTarget(_targetHandle);
         }
     }
 }

Runtime/ARFoundation/Overrides/PersistentAnchors/MeshDownload/Api/MeshDownloadHelper.cs

@@ -24,6 +24,7 @@ internal static class MeshDownloadHelper
         private static string configEndpointFormatter = "{0}/vps_frontend.protogen.Localizer/{1}";
         private static string meshingMethod = "GetMeshUrl";
         private static string graphMethod = "GetGraph";
+        private static string replacedNodeMethod = "GetReplacedNodes";
         private static string spaceDataMethod = "GetSpaceData";
         private const int KB = 1024;
 
@@ -228,7 +229,7 @@ await HttpClient.SendPostAsync<
         // 4. Add an entry for the each node and edge pair to the return list
         // 6. Add the last remaining node with no edge (origin of the space)
         // 7. Return the List<NodeToLoad> with node transforms and mesh urls
-        private static async Task<List<NodeToLoad>> GetNodesInSpace(string nodeId, Dictionary<string, string> headers)
+        private static async Task<List<NodeToLoad>> GetNodesInSpace(string nodeId, Dictionary<string, string> headers, bool searchForReplacedNode = true)
         {
             var nodesToLoad = new List<NodeToLoad>();
 
@@ -266,6 +267,16 @@ await HttpClient.SendPostAsync<
                     response.nodes == null ||
                     response.nodes.Length == 0)
                 {
+                    if ((response.nodes == null || response.nodes.Length == 0) && searchForReplacedNode)
+                    {
+                        // Check if the node has been replaced with a new active node
+                        var replacedNodeResponse = await TryGetNodesInSpaceForReplacedNode(nodeId, headers);
+                        if (replacedNodeResponse != null)
+                        {
+                            return replacedNodeResponse;
+                        }
+                    }
+
                     // This class uses Debug instead of ARLog to support editor logging without Lightship Native loaded
                     Debug.LogWarning("Failed to get nodes to load");
                     return null;
@@ -371,6 +382,62 @@ await HttpClient.SendPostAsync<
             return nodesToLoad;
         }
 
+        private static async Task<List<NodeToLoad>> TryGetNodesInSpaceForReplacedNode
+        (
+            string nodeId,
+            Dictionary<string, string> headers
+        )
+        {
+            var replacedNodeRequest = new MeshDownloadRequestResponse.GetReplacedNodesRequest
+            {
+                requestIdentifier = Guid.NewGuid().ToString("N").ToUpper(),
+                nodeIdentifiers = new []{nodeId}
+            };
+
+            var endpoint = GetUrlForMethod(replacedNodeMethod);
+            var replacedNodeResponse =
+                await HttpClient.SendPostAsync<
+                    MeshDownloadRequestResponse.GetReplacedNodesRequest,
+                    MeshDownloadRequestResponse.GetReplacedNodesResponse>
+                (
+                    endpoint,
+                    replacedNodeRequest,
+                    headers
+                );
+
+            if (replacedNodeResponse.Status == ResponseStatus.Success)
+            {
+                var response = replacedNodeResponse.Data;
+                if (response.transformToActiveNode != null && response.transformToActiveNode.Length > 0)
+                {
+                    var replacedNode = response.transformToActiveNode[0];
+                    var activeNode = replacedNode.activeNode;
+                    var transform = replacedNode.transformFromReplacedToActiveNode;
+
+                    var nodesInNewSpace = await GetNodesInSpace(activeNode, headers, false);
+                    if (nodesInNewSpace != null && nodesInNewSpace.Count > 0)
+                    {
+                        nodesInNewSpace.Add
+                        (
+                            new NodeToLoad
+                            (
+                                nodeId,
+                                nodesInNewSpace.First().spaceId,
+                                transform.translation,
+                                transform.rotation
+                            )
+                        );
+
+                        return nodesInNewSpace;
+                    }
+
+                    return null;
+                }
+            }
+
+            return null;
+        }
+
         // Use a HEAD request to get the total download size of the meshes
         private static async Task<ulong> GetTotalDownloadSize
         (