@rings-webgpu/core 1.0.32 → 1.0.34

package/dist/rings.es.max.js

@@ -42146,7 +42146,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.31";
+const version = "1.0.33";
 
 class Engine3D {
   /**
@@ -64067,25 +64067,10 @@ class LRUCache {
 class PriorityQueue {
   maxJobs = 6;
   // Maximum concurrent tasks
-  autoUpdate = true;
-  // Auto update
   priorityCallback = null;
   _items = [];
   _callbacks = /* @__PURE__ */ new Map();
   _currJobs = 0;
-  _scheduled = false;
-  _schedulingCallback;
-  constructor() {
-    this._schedulingCallback = (func) => {
-      requestAnimationFrame(func);
-    };
-  }
-  /**
-   * Set scheduling callback (can be used to customize scheduling strategy)
-   */
-  set schedulingCallback(cb) {
-    this._schedulingCallback = cb;
-  }
   /**
    * Check if there are tasks running or queued
    */
@@ -64127,9 +64112,6 @@ class PriorityQueue {
     };
     this._items.unshift(item);
     this._callbacks.set(item, data);
-    if (this.autoUpdate) {
-      this._scheduleJobRun();
-    }
     return promise;
   }
   /**
@@ -64161,17 +64143,11 @@ class PriorityQueue {
     toRemove.forEach((item) => this.remove(item));
   }
   /**
-   * Schedule task run
+   * Update queue - process pending tasks
+   * Should be called by TilesRenderer in its update() method
    */
-  _scheduleJobRun() {
-    if (this._scheduled) {
-      return;
-    }
-    this._scheduled = true;
-    this._schedulingCallback(() => {
-      this._scheduled = false;
-      this._tryRunJobs();
-    });
+  update() {
+    this._tryRunJobs();
   }
   /**
    * Try to run tasks
@@ -64182,9 +64158,6 @@ class PriorityQueue {
     let iterated = 0;
     const completedCallback = () => {
       this._currJobs--;
-      if (this.autoUpdate) {
-        this._scheduleJobRun();
-      }
     };
     while (maxJobs > this._currJobs && this._items.length > 0 && iterated < maxJobs) {
       this._currJobs++;
@@ -64934,6 +64907,7 @@ class TilesRenderer {
             basePath,
             null
           );
+          this.queueTileForDownload(rootTile);
           this._root = rootTile;
           const boundingVolume = new BoundingVolume(rootTile.boundingVolume);
           const sphere = new BoundingSphere();
@@ -64995,6 +64969,8 @@ class TilesRenderer {
       this.requestTileContents(queuedTiles[i]);
     }
     queuedTiles.length = 0;
+    loadQueue.update();
+    processNodeQueue.update();
     lruCache.scheduleUnload();
     const runningTasks = loadQueue.running || processNodeQueue.running;
     if (runningTasks === false && this.isLoading === true) {
@@ -65431,8 +65407,10 @@ class TilesRenderer {
           tileItem.loadingState = UNLOADED;
         });
       }
-      if (tile.active) {
+      {
         this.setTileActive(tile, true);
+        tile.active = true;
+        this.stats.active++;
       }
     } else {
       tile.loadingState = FAILED;
@@ -65479,36 +65457,18 @@ class TilesRenderer {
       }
     }
   }
-  /**
-   * Get children tiles that are loading and will be active
-   * Check if child is used in current frame (will be displayed) but not yet loaded
-   */
-  _getLoadingChildrenThatWillBeActive(tile) {
-    const loadingChildren = [];
-    const children = tile.children;
-    for (let i = 0, l = children.length; i < l; i++) {
-      const child = children[i];
-      if (child.loadingState !== LOADED && child.loadingState !== FAILED) {
-        loadingChildren.push(child);
-      }
-      if (child.children && child.children.length > 0) {
-        loadingChildren.push(...this._getLoadingChildrenThatWillBeActive(child));
-      }
-    }
-    return loadingChildren;
-  }
   /**
    * Check and process delayed hide tiles when a child finishes loading
    */
   _checkDelayedHideTiles() {
+    if (this.stats.downloading !== 0) {
+      return;
+    }
     for (const tile of this._delayedHideTiles) {
-      const stillLoading = this._getLoadingChildrenThatWillBeActive(tile);
-      if (stillLoading.length === 0) {
-        this._delayedHideTiles.delete(tile);
-        const scene = tile.cached.scene;
-        if (scene) {
-          scene.transform.enable = false;
-        }
+      this._delayedHideTiles.delete(tile);
+      const scene = tile.cached.scene;
+      if (scene) {
+        scene.transform.enable = false;
       }
     }
   }