@rings-webgpu/core 1.0.39 → 1.0.40

package/dist/rings.umd.max.js

@@ -42292,7 +42292,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.38";
+  const version = "1.0.39";
 
   class Engine3D {
     /**
@@ -55178,7 +55178,7 @@ fn frag(){
      * Update node before rendering
      */
     nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
-      if (this._validCount > 0 && view?.camera) {
+      if (this._validCount > 0 && view?.camera && this._frameCount >= 60) {
         if (view.camera.viewMatrix) {
           this.scheduleOrder(view.camera.viewMatrix);
         }
@@ -65924,11 +65924,11 @@ fn frag(){
         const wasVisible = tile.__wasSetVisible;
         const wasActive = tile.__wasSetActive;
         if (wasActive !== setActive) {
-          renderer.setTileActive(tile, setActive);
+          renderer.setTileDelayedActive(tile, setActive);
           tile.__wasSetActive = setActive;
         }
         if (wasVisible !== setVisible) {
-          renderer.setTileVisible(tile, setVisible);
+          renderer.setTileDelayedVisible(tile, setVisible);
           tile.__wasSetVisible = setVisible;
         }
       }
@@ -66301,6 +66301,8 @@ fn frag(){
     _activeTiles = /* @__PURE__ */ new Set();
     // Tiles that should be hidden but are delayed due to children loading
     _delayedHideTiles = /* @__PURE__ */ new Set();
+    _delayedVisibleTiles = /* @__PURE__ */ new Set();
+    _delayedActiveTiles = /* @__PURE__ */ new Set();
     // Rings-specific: Scene group
     group;
     // Rings-specific: Camera management
@@ -66419,6 +66421,8 @@ fn frag(){
       _usedSet.clear();
       this.updateCameraInfo();
       this._checkDelayedHideTiles();
+      this._checkDelayedActiveTiles();
+      this._checkDelayedVisibleTiles();
       markUsedTiles(root, this);
       markUsedSetLeaves(root, this);
       markVisibleTiles(root, this);
@@ -66852,7 +66856,6 @@ fn frag(){
       }
       if (scene) {
         tile.cached.scene = scene;
-        tile.loadingState = LOADED;
         const bytesUsed = this._estimateBytesUsed(scene);
         this._bytesUsed.set(scene, bytesUsed);
         this.lruCache.setMemoryUsage(tile, bytesUsed);
@@ -66870,10 +66873,21 @@ fn frag(){
           });
         }
         {
-          this.setTileActive(tile, true);
+          this.setTileImmediateActive(tile);
           tile.active = true;
+          tile.__wasSetActive = true;
           this.stats.active++;
         }
+        {
+          this.setTileImmediateVisible(tile);
+          tile.visible = true;
+          tile.__wasSetVisible = true;
+          this.stats.visible++;
+        }
+        tile.loadingState = LOADED;
+        tile.usedLastFrame = true;
+        markVisibleTiles(tile, this);
+        toggleTiles(tile, this);
       } else {
         tile.loadingState = FAILED;
         this.stats.failed++;
@@ -66889,33 +66903,46 @@ fn frag(){
     /**
      * Set tile active state
      */
-    setTileActive(tile, active) {
+    setTileDelayedActive(tile, active) {
       if (active) {
         this._activeTiles.add(tile);
         if (this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.delete(tile);
         }
+        if (!this._delayedActiveTiles.has(tile)) {
+          this._delayedActiveTiles.add(tile);
+        }
       } else {
         this._activeTiles.delete(tile);
+        if (!this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.add(tile);
+        }
+        if (this._delayedActiveTiles.has(tile)) {
+          this._delayedActiveTiles.delete(tile);
+        }
       }
-      const scene = tile.cached.scene;
-      if (!scene) {
-        return;
-      }
-      if (active) {
-        if (!this.group.entityChildren.includes(scene)) {
-          if (scene.parent) {
-            scene.parent.object3D.removeChild(scene);
+    }
+    setTileImmediateActive(tile) {
+      if (tile.hasRenderableContent) {
+        const scene = tile.cached.scene;
+        if (scene) {
+          if (!this.group.entityChildren.includes(scene)) {
+            if (scene.parent) {
+              scene.parent.object3D.removeChild(scene);
+            }
+            this.group.addChild(scene);
+          }
+          if (tile.cached.worldTransform) {
+            this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
           }
-          this.group.addChild(scene);
-        }
-        if (tile.cached.worldTransform) {
-          this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
         }
-        scene.transform.enable = true;
-      } else {
-        if (!this._delayedHideTiles.has(tile)) {
-          this._delayedHideTiles.add(tile);
+      }
+    }
+    setTileImmediateVisible(tile) {
+      if (tile.hasRenderableContent) {
+        const scene = tile.cached.scene;
+        if (scene) {
+          scene.transform.enable = true;
         }
       }
     }
@@ -66927,35 +66954,67 @@ fn frag(){
         return;
       }
       for (const tile of this._delayedHideTiles) {
-        this._delayedHideTiles.delete(tile);
         const scene = tile.cached.scene;
         if (scene) {
           scene.transform.enable = false;
+          this._delayedHideTiles.delete(tile);
+        }
+      }
+    }
+    _checkDelayedActiveTiles() {
+      for (const tile of this._delayedActiveTiles) {
+        if (tile.hasRenderableContent) {
+          const scene = tile.cached.scene;
+          if (scene) {
+            if (!this.group.entityChildren.includes(scene)) {
+              if (scene.parent) {
+                scene.parent.object3D.removeChild(scene);
+              }
+              this.group.addChild(scene);
+            }
+            if (tile.cached.worldTransform) {
+              this._applyWorldTransform(scene.transform, tile.cached.worldTransform);
+            }
+            this._delayedActiveTiles.delete(tile);
+          }
+        } else {
+          this._delayedActiveTiles.delete(tile);
+        }
+      }
+    }
+    _checkDelayedVisibleTiles() {
+      for (const tile of this._delayedVisibleTiles) {
+        if (tile.hasRenderableContent) {
+          const scene = tile.cached.scene;
+          if (scene) {
+            scene.transform.enable = true;
+            this._delayedVisibleTiles.delete(tile);
+          }
+        } else {
+          this._delayedVisibleTiles.delete(tile);
         }
       }
     }
     /**
      * Set tile visibility
      */
-    setTileVisible(tile, visible) {
+    setTileDelayedVisible(tile, visible) {
       if (visible) {
         this._visibleTiles.add(tile);
         if (this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.delete(tile);
         }
+        if (!this._delayedVisibleTiles.has(tile)) {
+          this._delayedVisibleTiles.add(tile);
+        }
       } else {
         this._visibleTiles.delete(tile);
-      }
-      const scene = tile.cached.scene;
-      if (!scene) {
-        return;
-      }
-      if (visible) {
-        scene.transform.enable = true;
-      } else {
         if (!this._delayedHideTiles.has(tile)) {
           this._delayedHideTiles.add(tile);
         }
+        if (this._delayedVisibleTiles.has(tile)) {
+          this._delayedVisibleTiles.delete(tile);
+        }
       }
     }
     /**

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

@@ -124,6 +124,8 @@ export declare class TilesRenderer {
     protected _root: Tile | null;
     protected _activeTiles: Set<Tile>;
     protected _delayedHideTiles: Set<Tile>;
+    protected _delayedVisibleTiles: Set<Tile>;
+    protected _delayedActiveTiles: Set<Tile>;
     readonly group: Object3D;
     cameras: Camera3D[];
     private _cameraMap;
@@ -206,15 +208,19 @@ export declare class TilesRenderer {
     /**
      * Set tile active state
      */
-    setTileActive(tile: Tile, active: boolean): void;
+    setTileDelayedActive(tile: Tile, active: boolean): void;
+    setTileImmediateActive(tile: Tile): void;
+    setTileImmediateVisible(tile: Tile): void;
     /**
      * Check and process delayed hide tiles when a child finishes loading
      */
     private _checkDelayedHideTiles;
+    private _checkDelayedActiveTiles;
+    private _checkDelayedVisibleTiles;
     /**
      * Set tile visibility
      */
-    setTileVisible(tile: Tile, visible: boolean): void;
+    setTileDelayedVisible(tile: Tile, visible: boolean): void;
     /**
      * Add tile to download queue
      */

package/package.json

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