@rings-webgpu/core 1.0.31 → 1.0.33

package/dist/rings.es.max.js

@@ -42146,7 +42146,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.30";
+const version = "1.0.32";
 
 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++;
@@ -64864,6 +64837,8 @@ class TilesRenderer {
   _root = null;
   // Active and visible tiles set
   _activeTiles = /* @__PURE__ */ new Set();
+  // Tiles that should be hidden but are delayed due to children loading
+  _delayedHideTiles = /* @__PURE__ */ new Set();
   // Rings-specific: Scene group
   group;
   // Rings-specific: Camera management
@@ -64932,6 +64907,7 @@ class TilesRenderer {
             basePath,
             null
           );
+          this.queueTileForDownload(rootTile);
           this._root = rootTile;
           const boundingVolume = new BoundingVolume(rootTile.boundingVolume);
           const sphere = new BoundingSphere();
@@ -64980,6 +64956,7 @@ class TilesRenderer {
     _usedSet.forEach((tile) => lruCache.markUnused(tile));
     _usedSet.clear();
     this.updateCameraInfo();
+    this._checkDelayedHideTiles();
     markUsedTiles(root, this);
     markUsedSetLeaves(root, this);
     markVisibleTiles(root, this);
@@ -64992,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) {
@@ -65449,6 +65428,9 @@ class TilesRenderer {
   setTileActive(tile, active) {
     if (active) {
       this._activeTiles.add(tile);
+      if (this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.delete(tile);
+      }
     } else {
       this._activeTiles.delete(tile);
     }
@@ -65468,7 +65450,61 @@ class TilesRenderer {
       }
       scene.transform.enable = true;
     } else {
-      scene.transform.enable = false;
+      if (!this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.add(tile);
+      }
+    }
+  }
+  _checkIsLoadingTileWillBeActive(tile) {
+    return tile.used && (tile.loadingState === LOADING || tile.loadingState === PARSING || !this._activeTiles.has(tile) || !this._visibleTiles.has(tile)) && tile.loadingState !== UNLOADED && tile.loadingState !== FAILED && tile.hasRenderableContent;
+  }
+  /**
+   * 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 (this._checkIsLoadingTileWillBeActive(child)) {
+        loadingChildren.push(child);
+      }
+      if (child.children && child.children.length > 0) {
+        loadingChildren.push(...this._getLoadingChildrenThatWillBeActive(child));
+      }
+    }
+    return loadingChildren;
+  }
+  /**
+   * Get parents tiles that are loading and will be active
+   * Check if parent is used in current frame (will be displayed) but not yet loaded
+   */
+  _getLoadingParentsThatWillBeActive(tile) {
+    const loadingParents = [];
+    const parent = tile.parent;
+    if (parent) {
+      if (this._checkIsLoadingTileWillBeActive(parent)) {
+        loadingParents.push(parent);
+      }
+    }
+    return loadingParents;
+  }
+  /**
+   * Check and process delayed hide tiles when a child finishes loading
+   */
+  _checkDelayedHideTiles() {
+    for (const tile of this._delayedHideTiles) {
+      const stillLoadingChildren = this._getLoadingChildrenThatWillBeActive(tile);
+      const stillLoadingParents = this._getLoadingParentsThatWillBeActive(tile);
+      const stillLoading = [...stillLoadingChildren, ...stillLoadingParents];
+      if (stillLoading.length === 0) {
+        this._delayedHideTiles.delete(tile);
+        const scene = tile.cached.scene;
+        if (scene) {
+          scene.transform.enable = false;
+        }
+      }
     }
   }
   /**
@@ -65477,6 +65513,9 @@ class TilesRenderer {
   setTileVisible(tile, visible) {
     if (visible) {
       this._visibleTiles.add(tile);
+      if (this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.delete(tile);
+      }
     } else {
       this._visibleTiles.delete(tile);
     }
@@ -65484,7 +65523,13 @@ class TilesRenderer {
     if (!scene) {
       return;
     }
-    scene.transform.enable = visible;
+    if (visible) {
+      scene.transform.enable = true;
+    } else {
+      if (!this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.add(tile);
+      }
+    }
   }
   /**
    * Add tile to download queue