fix perf regressions

Author: martyvona

Assets/Unity3DTiles/AbstractTilesetBehaviour.cs

@@ -60,6 +60,10 @@ public void LateUpdate()
 
             _lateUpdate();
 
+            RequestManager.ForEachQueuedDownload(DerateUnusedTilePriority);
+            RequestManager.ForEachActiveDownload(DerateUnusedTilePriority);
+            TileCache.ForEach(DerateUnusedTilePriority);
+
             int maxNewRequests = TileCache.HasMaxSize ? TileCache.MaxSize - TileCache.Count() : -1;
             RequestManager.Process(maxNewRequests);
 
@@ -106,6 +110,23 @@ public void LateUpdate()
             UpdateStats();
         }
 
+        private void DerateUnusedTilePriority(Unity3DTile tile)
+        {
+            if (!tile.FrameState.IsUsedThisFrame && !tile.FrameState.UsedLastFrame)
+            {
+                if (tile.FrameState.LastVisitedFrame < 0)
+                {
+                    tile.FrameState.Priority = float.MaxValue;
+                }
+                else
+                {
+                    float maxFrames = 1000;
+                    float framesSinceUsed = Mathf.Min(Time.frameCount - tile.FrameState.LastVisitedFrame, maxFrames);
+                    tile.FrameState.Priority = (1 + (framesSinceUsed / maxFrames));
+                }
+            }
+        }
+
         protected virtual void UpdateStats()
         {
             //override in subclass

Assets/Unity3DTiles/MultiTilesetBehaviour.cs

@@ -90,10 +90,25 @@ protected override void _lateUpdate()
 
         protected override void UpdateStats()
         {
-            foreach (var tileset in tilesets)
+            //this works but is very inefficient and drags down framerate significantly when many tilesets are loaded
+            //foreach (var tileset in tilesets)
+            //{
+            //    tileset.UpdateStats();
+            //}
+            RequestManager.ForEachQueuedDownload(t => { t.Tileset.Statistics.RequestQueueLength++; });
+            RequestManager.ForEachActiveDownload(t => { t.Tileset.Statistics.ActiveDownloads++; });
+            foreach (var tile in ProcessingQueue)
             {
-                tileset.UpdateStats();
+                tile.Tileset.Statistics.ProcessingQueueLength++;
             }
+            TileCache.ForEach(t => {
+                t.Tileset.Statistics.DownloadedTiles++;
+                if (t.ContentState == Unity3DTileContentState.READY)
+                {
+                    t.Tileset.Statistics.ReadyTiles++;
+                }
+            });
+            Unity3DTilesetStatistics.MaxLoadedTiles = TileCache.MaxSize;
             Stats = Unity3DTilesetStatistics.Aggregate(tilesets.Select(t => t.Statistics).ToArray());
         }
 

Assets/Unity3DTiles/RequestManager.cs

@@ -90,23 +90,6 @@ private set
             }
         }
 
-        public int Count(Func<Unity3DTile, bool> predicate = null)
-        {
-            if (predicate == null)
-            {
-                return queue.Count;
-            } 
-            int num = 0;
-            foreach (var request in queue)
-            {
-                if (predicate(request.Tile))
-                {
-                    num++;
-                }
-            }
-            return num;
-        }
-
         public IEnumerator<Unity3DTile> GetEnumerator()
         {
             foreach (var request in queue)
@@ -141,6 +124,23 @@ public RequestManager(Unity3DTilesetSceneOptions sceneOptions)
             this.sceneOptions = sceneOptions;
         }
 
+        public int Count(Func<Unity3DTile, bool> predicate = null)
+        {
+            if (predicate == null)
+            {
+                return queue.Count;
+            } 
+            int num = 0;
+            foreach (var request in queue)
+            {
+                if (predicate(request.Tile))
+                {
+                    num++;
+                }
+            }
+            return num;
+        }
+
         public int CountActiveDownloads(Func<Unity3DTile, bool> predicate = null)
         {
             if (predicate == null)
@@ -150,6 +150,22 @@ public int CountActiveDownloads(Func<Unity3DTile, bool> predicate = null)
             return activeDownloads.Count(predicate);
         }
 
+        public void ForEachQueuedDownload(Action<Unity3DTile> action)
+        {
+            foreach (var request in queue)
+            {
+                action(request.Tile);
+            }
+        }
+
+        public void ForEachActiveDownload(Action<Unity3DTile> action)
+        {
+            foreach (var tile in activeDownloads)
+            {
+                action(tile);
+            }
+        }
+
         public void EnqueRequest(Request request)
         {
             request.Tile.ContentState = Unity3DTileContentState.LOADING;

Assets/Unity3DTiles/TileCache.cs

@@ -35,15 +35,6 @@ public class TileCache
 
         private readonly List<Unity3DTile> tmpList = new List<Unity3DTile>();
 
-        public int Count(Func<Unity3DTile, bool> predicate = null)
-        {
-            if (predicate == null)
-            {
-                return list.Count - 1;
-            }
-            return list.Count(t => t != null && predicate(t));
-        }
-
         public bool HasMaxSize
         {
             get { return sceneOptions.CacheMaxSize > 0;  }
@@ -100,9 +91,33 @@ public TileCache(Unity3DTilesetSceneOptions sceneOptions)
             list.AddFirst(sentinel);
         }
 
+        public int Count(Func<Unity3DTile, bool> predicate = null)
+        {
+            if (predicate == null)
+            {
+                return list.Count - 1;
+            }
+            return list.Count(t => t != null && predicate(t));
+        }
+
+        public void ForEach(Action<Unity3DTile> action)
+        {
+            foreach (var tile in list)
+            {
+                if (tile != null)
+                {
+                    action(tile);
+                }
+            }
+        }
+
         public bool Add(Unity3DTile tile, out bool duplicate)
         {
             duplicate = false;
+            if (tile == null)
+            {
+                return false;
+            }
             if (nodeLookup.ContainsKey(tile))
             {
                 duplicate = true;

Assets/Unity3DTiles/Unity3DTile.cs

@@ -128,18 +128,21 @@ public void MarkUsed()
                 InUsedSet = true;
             }
 
-            public bool IsUsedThisFrame(int frameCount)
+            public bool IsUsedThisFrame
             {
-                return InUsedSet && LastVisitedFrame == frameCount;
+                get
+                {
+                    return InUsedSet && LastVisitedFrame == Time.frameCount;
+                }
             }
 
-            public void Reset(int frameCount)
+            public void Reset()
             {
-                if(LastVisitedFrame == frameCount)
+                if (LastVisitedFrame == Time.frameCount)
                 {
                     return;
                 }
-                LastVisitedFrame = frameCount;
+                LastVisitedFrame = Time.frameCount;
                 InUsedSet = false;
                 InFrustumSet = false;
                 IsUsedSetLeaf = false;