@rings-webgpu/core 1.0.31 → 1.0.33

package/dist/rings.umd.max.js

@@ -42153,7 +42153,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.30";
+  const version = "1.0.32";
 
   class Engine3D {
     /**
@@ -64074,25 +64074,10 @@ fn frag(){
   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
      */
@@ -64134,9 +64119,6 @@ fn frag(){
       };
       this._items.unshift(item);
       this._callbacks.set(item, data);
-      if (this.autoUpdate) {
-        this._scheduleJobRun();
-      }
       return promise;
     }
     /**
@@ -64168,17 +64150,11 @@ fn frag(){
       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
@@ -64189,9 +64165,6 @@ fn frag(){
       let iterated = 0;
       const completedCallback = () => {
         this._currJobs--;
-        if (this.autoUpdate) {
-          this._scheduleJobRun();
-        }
       };
       while (maxJobs > this._currJobs && this._items.length > 0 && iterated < maxJobs) {
         this._currJobs++;
@@ -64871,6 +64844,8 @@ fn frag(){
     _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
@@ -64939,6 +64914,7 @@ fn frag(){
               basePath,
               null
             );
+            this.queueTileForDownload(rootTile);
             this._root = rootTile;
             const boundingVolume = new BoundingVolume(rootTile.boundingVolume);
             const sphere = new BoundingSphere();
@@ -64987,6 +64963,7 @@ fn frag(){
       _usedSet.forEach((tile) => lruCache.markUnused(tile));
       _usedSet.clear();
       this.updateCameraInfo();
+      this._checkDelayedHideTiles();
       markUsedTiles(root, this);
       markUsedSetLeaves(root, this);
       markVisibleTiles(root, this);
@@ -64999,6 +64976,8 @@ fn frag(){
         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) {
@@ -65456,6 +65435,9 @@ fn frag(){
     setTileActive(tile, active) {
       if (active) {
         this._activeTiles.add(tile);
+        if (this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.delete(tile);
+        }
       } else {
         this._activeTiles.delete(tile);
       }
@@ -65475,7 +65457,61 @@ fn frag(){
         }
         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;
+          }
+        }
       }
     }
     /**
@@ -65484,6 +65520,9 @@ fn frag(){
     setTileVisible(tile, visible) {
       if (visible) {
         this._visibleTiles.add(tile);
+        if (this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.delete(tile);
+        }
       } else {
         this._visibleTiles.delete(tile);
       }
@@ -65491,7 +65530,13 @@ fn frag(){
       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

package/dist/types/loader/parser/tileRenderer/TilesRenderer.d.ts

@@ -123,6 +123,7 @@ export declare class TilesRenderer {
     protected rtcOffset: Vector3 | null;
     protected _root: Tile | null;
     protected _activeTiles: Set<Tile>;
+    protected _delayedHideTiles: Set<Tile>;
     readonly group: Object3D;
     cameras: Camera3D[];
     private _cameraMap;
@@ -206,6 +207,21 @@ export declare class TilesRenderer {
      * Set tile active state
      */
     setTileActive(tile: Tile, active: boolean): void;
+    private _checkIsLoadingTileWillBeActive;
+    /**
+     * 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
+     */
+    private _getLoadingChildrenThatWillBeActive;
+    /**
+     * 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
+     */
+    private _getLoadingParentsThatWillBeActive;
+    /**
+     * Check and process delayed hide tiles when a child finishes loading
+     */
+    private _checkDelayedHideTiles;
     /**
      * Set tile visibility
      */

package/dist/types/loader/parser/tileRenderer/utils/PriorityQueue.d.ts

@@ -14,18 +14,10 @@ export type TaskCallback = (item: Tile) => Promise<void> | void;
  */
 export declare class PriorityQueue {
     maxJobs: number;
-    autoUpdate: boolean;
     priorityCallback: PriorityCallback | null;
     private _items;
     private _callbacks;
     private _currJobs;
-    private _scheduled;
-    private _schedulingCallback;
-    constructor();
-    /**
-     * Set scheduling callback (can be used to customize scheduling strategy)
-     */
-    set schedulingCallback(cb: (func: () => void) => void);
     /**
      * Check if there are tasks running or queued
      */
@@ -51,9 +43,10 @@ export declare class PriorityQueue {
      */
     removeByFilter(filter: (item: Tile) => boolean): void;
     /**
-     * Schedule task run
+     * Update queue - process pending tasks
+     * Should be called by TilesRenderer in its update() method
      */
-    private _scheduleJobRun;
+    update(): void;
     /**
      * Try to run tasks
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {