3dtiles-inspector 0.2.6 → 0.2.8

package/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on Keep a Changelog and this project follows Semantic Versio
 
 ## [Unreleased]
 
+## [0.2.8] - 2026-05-13
+
+### Fixed
+
+- Fixed save-time crop memory spikes on large tilesets by limiting concurrent Gaussian Splat resource processing based on CPU parallelism, capped at 8 workers.
+- Fixed viewer stalls when many tiles are loaded by avoiding repeated tileset-wide leaf geometric-error scans during tile preprocessing.
+
+## [0.2.7] - 2026-05-10
+
+### Changed
+
+- Changed crop saves to remove local orphaned Gaussian Splat `.glb` / `.gltf` resources and private external buffers after fully cropped content is pruned from the tileset.
+- Updated `3d-tiles-rendererjs-3dgs-plugin` from `0.1.5` to `0.1.7`.
+
+### Fixed
+
+- Fixed cropped Gaussian Splat resources keeping stale glTF accessor counts after SPZ data is rewritten, which could make Cesium fail while generating splat textures.
+
 ## [0.2.6] - 2026-05-05
 
 ### Added

package/dist/inspector-assets/viewer/app.js

@@ -43855,6 +43855,12 @@ async function buildGaussianMeshSource(descriptor, abortSignal) {
   }
   return { extSplats };
 }
+function isXrPresenting(renderer) {
+  return renderer.xr.isPresenting;
+}
+function getUpdateSourceCamera(renderer, camera, xrPresenting = isXrPresenting(renderer)) {
+  return xrPresenting ? renderer.xr.getCamera() : camera;
+}
 function ensureCameraClone(cached, source) {
   if (!cached || cached.constructor !== source.constructor) {
     return source.clone();
@@ -43862,111 +43868,11 @@ function ensureCameraClone(cached, source) {
   cached.copy(source, false);
   return cached;
 }
-function hasGaussianSplatAncestor(node) {
-  let ancestor = node.parent;
-  while (ancestor) {
-    if (ancestor instanceof SplatMesh || isGaussianSplat(ancestor)) {
-      return true;
-    }
-    ancestor = ancestor.parent;
-  }
-  return false;
-}
-function isGlobalSplatEdit(node) {
-  return node instanceof SplatEdit && !hasGaussianSplatAncestor(node);
-}
-function isCameraRelativeNode(node) {
-  return isGaussianSplat(node) || isGlobalSplatEdit(node);
-}
-function hasCameraRelativeRootAncestor(node) {
-  let ancestor = node.parent;
-  while (ancestor) {
-    if (isCameraRelativeNode(ancestor)) {
-      return true;
-    }
-    ancestor = ancestor.parent;
-  }
-  return false;
-}
-function cloneSplatRootSnapshot(node) {
-  return {
-    kind: "splat",
-    opacity: node.opacity,
-    matrixWorld: node.matrixWorld.clone()
-  };
-}
-function cloneSplatEditSdfSnapshot(sdf) {
-  return {
-    uuid: sdf.uuid,
-    matrixWorld: sdf.matrixWorld.clone(),
-    type: sdf.type,
-    invert: sdf.invert,
-    opacity: sdf.opacity,
-    color: sdf.color.clone(),
-    radius: sdf.radius,
-    displace: sdf.displace.clone(),
-    scale: sdf.scale.clone()
-  };
-}
-function cloneSplatEditRootSnapshot(edit) {
-  edit.updateMatrixWorld(true);
-  const sdfs = [];
-  const sourceSdfs = edit.sdfs;
-  if (sourceSdfs != null) {
-    for (const sdf of sourceSdfs) {
-      sdf.updateMatrixWorld(true);
-      sdfs.push(cloneSplatEditSdfSnapshot(sdf));
-    }
-  } else {
-    edit.traverseVisible((child) => {
-      if (child instanceof SplatEditSdf) {
-        child.updateMatrixWorld(true);
-        sdfs.push(cloneSplatEditSdfSnapshot(child));
-      }
-    });
-  }
-  return {
-    kind: "edit",
-    matrixWorld: edit.matrixWorld.clone(),
-    ordering: edit.ordering,
-    rgbaBlendMode: edit.rgbaBlendMode,
-    sdfSmooth: edit.sdfSmooth,
-    softEdge: edit.softEdge,
-    invert: edit.invert,
-    sdfs
-  };
-}
-function cloneCameraRelativeRootSnapshot(node) {
-  return node instanceof SplatEdit ? cloneSplatEditRootSnapshot(node) : cloneSplatRootSnapshot(node);
-}
-function areSplatRootStatesEqual(a2, b5) {
-  return a2.opacity === b5.opacity && a2.matrixWorld.equals(b5.matrixWorld);
-}
-function areSplatEditSdfStatesEqual(a2, b5) {
-  return a2.uuid === b5.uuid && a2.type === b5.type && a2.invert === b5.invert && a2.opacity === b5.opacity && a2.radius === b5.radius && a2.matrixWorld.equals(b5.matrixWorld) && a2.color.equals(b5.color) && a2.displace.equals(b5.displace) && a2.scale.equals(b5.scale);
+function isGaussianSplatNode(node) {
+  return node instanceof SplatMesh || isGaussianSplat(node);
 }
-function areSplatEditRootStatesEqual(a2, b5) {
-  if (!a2.matrixWorld.equals(b5.matrixWorld) || a2.ordering !== b5.ordering || a2.rgbaBlendMode !== b5.rgbaBlendMode || a2.sdfSmooth !== b5.sdfSmooth || a2.softEdge !== b5.softEdge || a2.invert !== b5.invert || a2.sdfs.length !== b5.sdfs.length) {
-    return false;
-  }
-  for (let i = 0; i < a2.sdfs.length; i++) {
-    if (!areSplatEditSdfStatesEqual(a2.sdfs[i], b5.sdfs[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-function areCameraRelativeRootStatesEqual(a2, b5) {
-  if (a2 === b5) {
-    return true;
-  }
-  if (!a2 || !b5 || a2.kind !== b5.kind) {
-    return false;
-  }
-  if (a2.kind === "splat") {
-    return b5.kind === "splat" && areSplatRootStatesEqual(a2, b5);
-  }
-  return b5.kind === "edit" && areSplatEditRootStatesEqual(a2, b5);
+function isCameraRelativeEdit(node, hasGaussianSplatAncestor) {
+  return node instanceof SplatEdit && !hasGaussianSplatAncestor;
 }
 function normalizeSparkRendererOptions(host, includeCustomDefaults = true) {
   const source = host.sparkRendererOptions ?? {};
@@ -44154,7 +44060,7 @@ function isGaussianSplat(object) {
 function isGaussianSplatScene(scene) {
   return Boolean(scene?.userData?.gaussianSplatScene);
 }
-var _translation, _rotation, _scale, _identityMatrix2, _tempNodeMatrix, _textDecoder, _identityMatrix22, _cameraInverseWorldMatrix, _parentInverseWorldMatrix, _rebasedLocalMatrix, _displayFrameInverseWorldMatrix, _relativeRenderCameraMatrix, _cameraWorldPosition, _cameraWorldDirection, _cameraPositionEpsilonSq, _cameraDirectionDotThreshold, _updateCamera, _renderCamera, _lastCameraPosition, _lastCameraDirection, _hasLastCameraPose, _lastRootStates, _currentRootStates, _rebasedRootsPool, _rebasedRootsCount, _hadRebasedLastFrame, _CameraRelativeSparkRenderer_instances, shouldUpdate_fn, getUpdateCamera_fn, getRenderCamera_fn, rebaseCameraRelativeRoots_fn, restoreCameraRelativeRoots_fn, _a2, CameraRelativeSparkRenderer, _sharedSparkManagersByScene, _sharedSparkManagersByRenderer, CUSTOM_DEFAULT_OPTIONS, _sparkRenderer, _scene, _sparkRendererOptions, _notifyHandle, _disposeHandle, _tilesRenderers, _disposed, _SharedSparkRendererManager_instances, dispose_fn, stopScheduledNotifications_fn, scheduleSortUpdatedNotification_fn, waitForSortAndDispose_fn, _a3, SharedSparkRendererManager, SPARK_RENDERER_OPTION_KEYS, MAX_GAUSSIAN_MESH_INIT_CONCURRENCY, _sceneMatrix, _gaussianFadeValueWatched, _host, _sparkManager, _GaussianSplatPlugin_instances, disposeSplatScene_fn, getSplatMeshes_fn, createMeshForDescriptor_fn, _a4, GaussianSplatPlugin;
+var _translation, _rotation, _scale, _identityMatrix2, _tempNodeMatrix, _textDecoder, _identityMatrix22, _cameraInverseWorldMatrix, _parentInverseWorldMatrix, _rebasedLocalMatrix, _displayFrameInverseWorldMatrix, _relativeRenderCameraMatrix, _updateCamera, _renderCamera, _cameraWorldSnapshot, _lastXrHandledFrame, _rebasedRootsPool, _rebasedRootsCount, _hadRebasedLastFrame, _CameraRelativeSparkRenderer_instances, updateSparkIfNeeded_fn, getUpdateCamera_fn, getRenderCamera_fn, rebaseCameraRelativeRoots_fn, visitVisibleCameraRelativeRoots_fn, rebaseCameraRelativeRoot_fn, restoreCameraRelativeRoots_fn, _a2, CameraRelativeSparkRenderer, _sharedSparkManagersByScene, _sharedSparkManagersByRenderer, CUSTOM_DEFAULT_OPTIONS, _sparkRenderer, _scene, _sparkRendererOptions, _notifyHandle, _disposeHandle, _tilesRenderers, _disposed, _SharedSparkRendererManager_instances, dispose_fn, stopScheduledNotifications_fn, scheduleSortUpdatedNotification_fn, waitForSortAndDispose_fn, _a3, SharedSparkRendererManager, SPARK_RENDERER_OPTION_KEYS, MAX_GAUSSIAN_MESH_INIT_CONCURRENCY, _sceneMatrix, _gaussianFadeValueWatched, _host, _sparkManager, _GaussianSplatPlugin_instances, disposeSplatScene_fn, getSplatMeshes_fn, createMeshForDescriptor_fn, _a4, GaussianSplatPlugin;
 var init_dist = __esm({
   "node_modules/3d-tiles-rendererjs-3dgs-plugin/dist/index.js"() {
     init_spark_module();
@@ -44175,10 +44081,6 @@ var init_dist = __esm({
     _rebasedLocalMatrix = new Matrix4();
     _displayFrameInverseWorldMatrix = new Matrix4();
     _relativeRenderCameraMatrix = new Matrix4();
-    _cameraWorldPosition = new Vector3();
-    _cameraWorldDirection = new Vector3();
-    _cameraPositionEpsilonSq = 1e-6;
-    _cameraDirectionDotThreshold = 1 - 1e-3;
     CameraRelativeSparkRenderer = (_a2 = class extends SparkRenderer {
       constructor(renderer, options = {}) {
         super({
@@ -44190,11 +44092,8 @@ var init_dist = __esm({
         __privateAdd(this, _CameraRelativeSparkRenderer_instances);
         __privateAdd(this, _updateCamera, null);
         __privateAdd(this, _renderCamera, null);
-        __privateAdd(this, _lastCameraPosition, new Vector3());
-        __privateAdd(this, _lastCameraDirection, new Vector3());
-        __privateAdd(this, _hasLastCameraPose, false);
-        __privateAdd(this, _lastRootStates, /* @__PURE__ */ new Map());
-        __privateAdd(this, _currentRootStates, /* @__PURE__ */ new Map());
+        __privateAdd(this, _cameraWorldSnapshot, new Matrix4());
+        __privateAdd(this, _lastXrHandledFrame, -1);
         __privateAdd(this, _rebasedRootsPool, []);
         __privateAdd(this, _rebasedRootsCount, 0);
         __privateAdd(this, _hadRebasedLastFrame, false);
@@ -44203,56 +44102,64 @@ var init_dist = __esm({
         };
       }
       onBeforeRender(renderer, scene, camera) {
-        camera.updateMatrixWorld(true);
-        const rebasedCount = __privateMethod(this, _CameraRelativeSparkRenderer_instances, rebaseCameraRelativeRoots_fn).call(this, scene, camera);
+        const xrPresenting = isXrPresenting(renderer);
+        const updateSourceCamera = getUpdateSourceCamera(
+          renderer,
+          camera,
+          xrPresenting
+        );
+        if (!xrPresenting) {
+          camera.updateMatrixWorld(true);
+        }
+        const rebasedCount = __privateMethod(this, _CameraRelativeSparkRenderer_instances, rebaseCameraRelativeRoots_fn).call(this, scene, updateSourceCamera);
         const hasRebased = rebasedCount > 0;
+        const renderFrame = renderer.info.render.frame;
+        const shouldHandleFrameState = !xrPresenting || __privateGet(this, _lastXrHandledFrame) !== renderFrame;
         try {
-          if ((hasRebased || __privateGet(this, _hadRebasedLastFrame)) && __privateMethod(this, _CameraRelativeSparkRenderer_instances, shouldUpdate_fn).call(this, camera)) {
-            const updateCamera = __privateMethod(this, _CameraRelativeSparkRenderer_instances, getUpdateCamera_fn).call(this, camera);
+          if (shouldHandleFrameState) {
+            __privateSet(this, _lastXrHandledFrame, renderFrame);
+          }
+          if ((hasRebased || __privateGet(this, _hadRebasedLastFrame)) && shouldHandleFrameState) {
+            const updateCamera = __privateMethod(this, _CameraRelativeSparkRenderer_instances, getUpdateCamera_fn).call(this, updateSourceCamera);
             const prevDisplay = this.display;
             const prevCurrent = this.current;
-            const cameraWorldSnapshot = camera.matrixWorld.clone();
-            void this.update({
+            const cameraWorldSnapshot = __privateGet(this, _cameraWorldSnapshot).copy(
+              updateSourceCamera.matrixWorld
+            );
+            void __privateMethod(this, _CameraRelativeSparkRenderer_instances, updateSparkIfNeeded_fn).call(this, {
               scene,
               camera: updateCamera
+            }).catch((error) => {
+              console.error(
+                "CameraRelativeSparkRenderer: Spark update failed",
+                error
+              );
             });
-            const updateAccepted = this.current !== prevCurrent || this.display !== prevDisplay;
             if (this.current !== prevCurrent) {
               this.current.viewToWorld.copy(cameraWorldSnapshot);
             }
             if (this.display !== prevDisplay) {
               this.display.viewToWorld.copy(cameraWorldSnapshot);
             }
-            if (updateAccepted) {
-              __privateGet(this, _lastCameraPosition).copy(_cameraWorldPosition);
-              __privateGet(this, _lastCameraDirection).copy(_cameraWorldDirection);
-              __privateSet(this, _hasLastCameraPose, true);
-              __privateSet(this, _lastRootStates, new Map(__privateGet(this, _currentRootStates)));
-            }
           }
-          __privateSet(this, _hadRebasedLastFrame, hasRebased);
+          if (shouldHandleFrameState) {
+            __privateSet(this, _hadRebasedLastFrame, hasRebased);
+          }
           const renderCamera = hasRebased ? __privateMethod(this, _CameraRelativeSparkRenderer_instances, getRenderCamera_fn).call(this, camera) : camera;
           super.onBeforeRender(renderer, scene, renderCamera);
         } finally {
           __privateMethod(this, _CameraRelativeSparkRenderer_instances, restoreCameraRelativeRoots_fn).call(this);
         }
       }
-    }, _updateCamera = new WeakMap(), _renderCamera = new WeakMap(), _lastCameraPosition = new WeakMap(), _lastCameraDirection = new WeakMap(), _hasLastCameraPose = new WeakMap(), _lastRootStates = new WeakMap(), _currentRootStates = new WeakMap(), _rebasedRootsPool = new WeakMap(), _rebasedRootsCount = new WeakMap(), _hadRebasedLastFrame = new WeakMap(), _CameraRelativeSparkRenderer_instances = new WeakSet(), shouldUpdate_fn = function(camera) {
-      camera.getWorldPosition(_cameraWorldPosition);
-      camera.getWorldDirection(_cameraWorldDirection);
-      const poseChanged = !__privateGet(this, _hasLastCameraPose) || _cameraWorldPosition.distanceToSquared(__privateGet(this, _lastCameraPosition)) > _cameraPositionEpsilonSq || _cameraWorldDirection.dot(__privateGet(this, _lastCameraDirection)) < _cameraDirectionDotThreshold;
-      const current = __privateGet(this, _currentRootStates);
-      const last = __privateGet(this, _lastRootStates);
-      let rootsChanged = current.size !== last.size;
-      if (!rootsChanged) {
-        for (const [uuid, state] of current) {
-          if (!areCameraRelativeRootStatesEqual(state, last.get(uuid))) {
-            rootsChanged = true;
-            break;
-          }
-        }
-      }
-      return poseChanged || rootsChanged;
+    }, _updateCamera = new WeakMap(), _renderCamera = new WeakMap(), _cameraWorldSnapshot = new WeakMap(), _lastXrHandledFrame = new WeakMap(), _rebasedRootsPool = new WeakMap(), _rebasedRootsCount = new WeakMap(), _hadRebasedLastFrame = new WeakMap(), _CameraRelativeSparkRenderer_instances = new WeakSet(), updateSparkIfNeeded_fn = function({
+      scene,
+      camera
+    }) {
+      return this.updateInternal({
+        scene,
+        camera,
+        autoUpdate: true
+      });
     }, /**
      * Identity camera for the update pass - makes Spark treat
      * the camera's own frame as the reference frame.
@@ -44291,55 +44198,63 @@ var init_dist = __esm({
       return renderCamera;
     }, rebaseCameraRelativeRoots_fn = function(scene, camera) {
       __privateSet(this, _rebasedRootsCount, 0);
-      __privateGet(this, _currentRootStates).clear();
       _cameraInverseWorldMatrix.copy(camera.matrixWorld).invert();
-      scene.traverseVisible((node) => {
-        if (!isCameraRelativeNode(node)) {
-          return;
-        }
-        __privateGet(this, _currentRootStates).set(
-          node.uuid,
-          cloneCameraRelativeRootSnapshot(node)
-        );
-        if (hasCameraRelativeRootAncestor(node)) {
-          return;
-        }
-        const idx = __privateWrapper(this, _rebasedRootsCount)._++;
-        const pool = __privateGet(this, _rebasedRootsPool);
-        if (idx >= pool.length) {
-          pool.push({
-            target: node,
-            originalMatrix: node.matrix.clone(),
-            originalMatrixAutoUpdate: node.matrixAutoUpdate
-          });
-        } else {
-          const entry = pool[idx];
-          entry.target = node;
-          entry.originalMatrix.copy(node.matrix);
-          entry.originalMatrixAutoUpdate = node.matrixAutoUpdate;
-        }
-        const parent2 = node.parent;
-        if (!parent2 || parent2 === scene) {
-          _rebasedLocalMatrix.copy(_cameraInverseWorldMatrix).multiply(node.matrixWorld);
-        } else {
-          _rebasedLocalMatrix.copy(_parentInverseWorldMatrix.copy(parent2.matrixWorld).invert()).multiply(_cameraInverseWorldMatrix).multiply(node.matrixWorld);
-        }
-        node.matrixAutoUpdate = false;
-        node.matrix.copy(_rebasedLocalMatrix);
-        node.matrixWorldNeedsUpdate = true;
-        node.updateMatrixWorld(true);
-      });
+      __privateMethod(this, _CameraRelativeSparkRenderer_instances, visitVisibleCameraRelativeRoots_fn).call(this, scene, scene, false, false);
       return __privateGet(this, _rebasedRootsCount);
+    }, visitVisibleCameraRelativeRoots_fn = function(node, scene, hasGaussianSplatAncestor, hasCameraRelativeAncestor) {
+      if (!node.visible) {
+        return;
+      }
+      const isSplatNode = isGaussianSplatNode(node);
+      const isCameraRelativeNode = isSplatNode || isCameraRelativeEdit(node, hasGaussianSplatAncestor);
+      if (isCameraRelativeNode && !hasCameraRelativeAncestor) {
+        __privateMethod(this, _CameraRelativeSparkRenderer_instances, rebaseCameraRelativeRoot_fn).call(this, node);
+      }
+      const nextHasGaussianSplatAncestor = hasGaussianSplatAncestor || isSplatNode;
+      const nextHasCameraRelativeAncestor = hasCameraRelativeAncestor || isCameraRelativeNode;
+      const { children } = node;
+      for (let i = 0, l = children.length; i < l; i++) {
+        __privateMethod(this, _CameraRelativeSparkRenderer_instances, visitVisibleCameraRelativeRoots_fn).call(this, children[i], scene, nextHasGaussianSplatAncestor, nextHasCameraRelativeAncestor);
+      }
+    }, rebaseCameraRelativeRoot_fn = function(node) {
+      const idx = __privateWrapper(this, _rebasedRootsCount)._++;
+      const pool = __privateGet(this, _rebasedRootsPool);
+      if (idx >= pool.length) {
+        pool.push({
+          target: node,
+          originalMatrix: node.matrix.clone(),
+          originalMatrixAutoUpdate: node.matrixAutoUpdate
+        });
+      } else {
+        const entry = pool[idx];
+        entry.target = node;
+        entry.originalMatrix.copy(node.matrix);
+        entry.originalMatrixAutoUpdate = node.matrixAutoUpdate;
+      }
+      const parent2 = node.parent;
+      if (!parent2) {
+        _rebasedLocalMatrix.copy(_cameraInverseWorldMatrix).multiply(node.matrixWorld);
+      } else {
+        _rebasedLocalMatrix.copy(_parentInverseWorldMatrix.copy(parent2.matrixWorld).invert()).multiply(_cameraInverseWorldMatrix).multiply(node.matrixWorld);
+      }
+      node.matrixAutoUpdate = false;
+      node.matrix.copy(_rebasedLocalMatrix);
+      node.matrixWorldNeedsUpdate = true;
+      node.updateMatrixWorld(true);
     }, restoreCameraRelativeRoots_fn = function() {
       const pool = __privateGet(this, _rebasedRootsPool);
       for (let i = __privateGet(this, _rebasedRootsCount) - 1; i >= 0; i--) {
         const { target, originalMatrix, originalMatrixAutoUpdate } = pool[i];
+        if (!target) continue;
         target.matrix.copy(originalMatrix);
         target.matrixAutoUpdate = originalMatrixAutoUpdate;
         target.matrixWorldNeedsUpdate = true;
       }
       for (let i = 0; i < __privateGet(this, _rebasedRootsCount); i++) {
-        pool[i].target.updateMatrixWorld(true);
+        pool[i].target?.updateMatrixWorld(true);
+      }
+      for (let i = __privateGet(this, _rebasedRootsCount); i < pool.length; i++) {
+        pool[i].target = null;
       }
     }, _a2);
     _sharedSparkManagersByScene = /* @__PURE__ */ new WeakMap();
@@ -45373,6 +45288,9 @@ function createGeometricErrorController({
   getTiles
 }) {
   const originalTileGeometricErrors = /* @__PURE__ */ new WeakMap();
+  let knownTileChildCounts = /* @__PURE__ */ new WeakMap();
+  let cachedGlobalLeafGeometricError = null;
+  let cachedGlobalLeafGeometricErrorRoot = null;
   let geometricErrorScaleExponent = 0;
   let geometricErrorScale = 1;
   let lastSavedGeometricErrorScale = 1;
@@ -45385,6 +45303,39 @@ function createGeometricErrorController({
   function getEffectiveGeometricErrorLayerScale() {
     return lastSavedGeometricErrorLayerScale * geometricErrorLayerScale;
   }
+  function getTilesRoot() {
+    return getTiles()?.root || null;
+  }
+  function getCachedGlobalLeafGeometricError() {
+    const root = getTilesRoot();
+    if (cachedGlobalLeafGeometricErrorRoot !== root) {
+      cachedGlobalLeafGeometricErrorRoot = root;
+      cachedGlobalLeafGeometricError = null;
+      knownTileChildCounts = /* @__PURE__ */ new WeakMap();
+    }
+    return cachedGlobalLeafGeometricError;
+  }
+  function setCachedGlobalLeafGeometricError(leafGeometricError) {
+    cachedGlobalLeafGeometricErrorRoot = getTilesRoot();
+    cachedGlobalLeafGeometricError = leafGeometricError;
+  }
+  function clearCachedGlobalLeafGeometricError() {
+    cachedGlobalLeafGeometricError = null;
+  }
+  function trackTileChildCount(tile, children) {
+    knownTileChildCounts.set(tile, children.length);
+  }
+  function invalidateLeafCacheIfParentChildrenChanged(parentTile) {
+    if (!parentTile || typeof parentTile !== "object") {
+      return;
+    }
+    const children = Array.isArray(parentTile.children) ? parentTile.children : [];
+    const knownChildCount = knownTileChildCounts.get(parentTile);
+    if (cachedGlobalLeafGeometricError !== null && knownChildCount !== children.length) {
+      clearCachedGlobalLeafGeometricError();
+    }
+    trackTileChildCount(parentTile, children);
+  }
   function updateTilesetErrorTarget() {
     const tiles = getTiles();
     if (!tiles) {
@@ -45423,6 +45374,7 @@ function createGeometricErrorController({
     visited.add(tile);
     let leafGeometricError = null;
     const children = Array.isArray(tile.children) ? tile.children : [];
+    trackTileChildCount(tile, children);
     for (const child of children) {
       const childLeafGeometricError = getKnownTileLeafGeometricError(
         child,
@@ -45435,31 +45387,58 @@ function createGeometricErrorController({
     visited.delete(tile);
     return leafGeometricError === null ? originalGeometricError : leafGeometricError;
   }
-  function getGlobalTileLeafGeometricError(tile) {
+  function getGlobalTileLeafGeometricError(tile, { forceRefresh = false } = {}) {
+    if (!forceRefresh) {
+      const cachedLeafGeometricError = getCachedGlobalLeafGeometricError();
+      if (cachedLeafGeometricError !== null) {
+        return cachedLeafGeometricError;
+      }
+    }
     const tiles = getTiles();
     const rootLeafGeometricError = tiles?.root ? getKnownTileLeafGeometricError(tiles.root) : null;
+    if (tiles?.root && tile === tiles.root) {
+      setCachedGlobalLeafGeometricError(rootLeafGeometricError);
+      return rootLeafGeometricError;
+    }
     const tileLeafGeometricError = getKnownTileLeafGeometricError(tile);
+    let leafGeometricError = null;
     if (rootLeafGeometricError === null) {
-      return tileLeafGeometricError;
-    }
-    if (tileLeafGeometricError === null) {
-      return rootLeafGeometricError;
+      leafGeometricError = tileLeafGeometricError;
+    } else if (tileLeafGeometricError === null) {
+      leafGeometricError = rootLeafGeometricError;
+    } else {
+      leafGeometricError = Math.min(
+        rootLeafGeometricError,
+        tileLeafGeometricError
+      );
     }
-    return Math.min(rootLeafGeometricError, tileLeafGeometricError);
+    setCachedGlobalLeafGeometricError(leafGeometricError);
+    return leafGeometricError;
   }
-  function applyLayerScaleToTile(tile, leafGeometricError = getGlobalTileLeafGeometricError(tile)) {
+  function applyLayerScaleToTile(tile, leafGeometricError = null, parentTile = null) {
+    invalidateLeafCacheIfParentChildrenChanged(parentTile);
     const originalGeometricError = getOriginalTileGeometricError(tile);
-    if (originalGeometricError === null || leafGeometricError === null) {
+    if (originalGeometricError === null) {
+      return;
+    }
+    const layerScale = getEffectiveGeometricErrorLayerScale();
+    if (layerScale === 1) {
+      tile.geometricError = originalGeometricError;
+      return;
+    }
+    const effectiveLeafGeometricError = leafGeometricError ?? getGlobalTileLeafGeometricError(tile);
+    if (effectiveLeafGeometricError === null) {
       return;
     }
-    tile.geometricError = leafGeometricError + (originalGeometricError - leafGeometricError) * getEffectiveGeometricErrorLayerScale();
+    tile.geometricError = effectiveLeafGeometricError + (originalGeometricError - effectiveLeafGeometricError) * layerScale;
   }
   function applyLayerScaleToTileset() {
     const tiles = getTiles();
     if (!tiles) {
       return;
     }
-    const leafGeometricError = getGlobalTileLeafGeometricError(tiles.root);
+    const layerScale = getEffectiveGeometricErrorLayerScale();
+    const leafGeometricError = layerScale === 1 ? null : getGlobalTileLeafGeometricError(tiles.root, { forceRefresh: true });
     tiles.traverse(
       (tile) => {
         applyLayerScaleToTile(tile, leafGeometricError);
@@ -63334,8 +63313,8 @@ function createTerrainGlobeTiles(options) {
 function createGeometricErrorLayerScalePlugin(preprocessNode) {
   return {
     name: "GeometricErrorLayerScalePlugin",
-    preprocessNode(tile) {
-      preprocessNode(tile);
+    preprocessNode(tile, tilesetDir, parentTile) {
+      preprocessNode(tile, null, parentTile);
     }
   };
 }
@@ -71652,10 +71631,11 @@ var require_app = __commonJS({
           const processedSplatResources = Number(
             payload.processedSplatResources || 0
           );
+          const deletedSplatFiles = Number(payload.deletedSplatFiles || 0);
           cropController.clearAll();
           loadTileset(TILESET_URL, { frameOnLoad: false });
           setStatus(
-            `Saved transform and deleted ${deletedSplats} cropped splats from ${processedSplatResources} splat resource${processedSplatResources === 1 ? "" : "s"}. Reloading tileset.`
+            `Saved transform and deleted ${deletedSplats} cropped splats from ${processedSplatResources} splat resource${processedSplatResources === 1 ? "" : "s"}${deletedSplatFiles > 0 ? `, removing ${deletedSplatFiles} orphaned file${deletedSplatFiles === 1 ? "" : "s"}` : ""}. Reloading tileset.`
           );
         } else {
           setStatus(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3dtiles-inspector",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Inspect, align, and save local 3D Tiles root transforms in an interactive browser session.",
   "author": "William Liu <lyz15972107087@gmail.com>",
   "license": "Apache-2.0",
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "3d-tiles-renderer": "0.4.24",
-    "3d-tiles-rendererjs-3dgs-plugin": "0.1.5",
+    "3d-tiles-rendererjs-3dgs-plugin": "0.1.7",
     "cesium": "1.140.0",
     "esbuild": "^0.25.11"
   },

package/src/server/saveTransform.js

@@ -471,6 +471,8 @@ async function saveViewerTransform(
   return {
     transform: nextRoot,
     deletedSplats: cropResult.deletedSplats,
+    deletedSplatFiles: cropResult.deletedSplatFiles,
+    failedSplatFileDeletes: cropResult.failedSplatFileDeletes,
     processedSplatResources: cropResult.processedSplatResources,
   };
 }

package/src/server/saveTransformHandler.js

@@ -23,6 +23,8 @@ function createSaveTransformResponsePayload(
     transform: saveResult.transform,
     geometricErrorLayerScale: normalizedGeometricErrorLayerScale,
     geometricErrorScale: normalizedGeometricErrorScale,
+    deletedSplatFiles: saveResult.deletedSplatFiles,
+    failedSplatFileDeletes: saveResult.failedSplatFileDeletes,
     deletedSplats: saveResult.deletedSplats,
     processedSplatResources: saveResult.processedSplatResources,
   };

package/src/server/splatCrop/gaussianPrimitives.js

@@ -239,6 +239,53 @@ function removeMeshPrimitives(resource, descriptors) {
   return removed;
 }
 
+function updateGaussianPrimitiveAccessorCounts(resource, descriptors, count) {
+  if (!Number.isInteger(count) || count < 0) {
+    throw new InspectorError('Gaussian accessor count must be a non-negative integer.');
+  }
+
+  const updatedAccessors = new Set();
+  descriptors.forEach((descriptor) => {
+    if (
+      !Number.isInteger(descriptor.meshIndex) ||
+      !Number.isInteger(descriptor.primitiveIndex)
+    ) {
+      return;
+    }
+
+    const primitive =
+      resource.json.meshes?.[descriptor.meshIndex]?.primitives?.[
+        descriptor.primitiveIndex
+      ];
+    const attributes = primitive?.attributes;
+    if (!attributes || typeof attributes !== 'object') {
+      return;
+    }
+
+    Object.values(attributes).forEach((accessorIndex) => {
+      if (
+        !Number.isInteger(accessorIndex) ||
+        accessorIndex < 0 ||
+        accessorIndex >= (resource.json.accessors?.length || 0)
+      ) {
+        return;
+      }
+
+      const accessor = resource.json.accessors[accessorIndex];
+      if (!accessor || typeof accessor !== 'object') {
+        return;
+      }
+
+      if (accessor.count !== count) {
+        accessor.count = count;
+        updatedAccessors.add(accessorIndex);
+      }
+    });
+  });
+
+  return updatedAccessors.size;
+}
+
 module.exports = {
   collectGaussianPrimitiveDescriptors,
   getRootUpRotationMatrix,
@@ -247,4 +294,5 @@ module.exports = {
   hasNonGaussianScenePrimitives,
   hasScenePrimitives,
   removeMeshPrimitives,
+  updateGaussianPrimitiveAccessorCounts,
 };

package/src/server/splatCrop/gltfResource.js

@@ -70,7 +70,7 @@ function parseGlb(filePath) {
     if (chunkType === GLB_JSON_CHUNK_TYPE) {
       json = JSON.parse(chunk.toString('utf8').replace(/\0+$/g, '').trimEnd());
     } else if (chunkType === GLB_BIN_CHUNK_TYPE && !bin) {
-      bin = Buffer.from(chunk);
+      bin = chunk;
     }
 
     offset = chunkEnd;
@@ -190,7 +190,7 @@ function loadResourceBuffer(resource, bufferIndex) {
         `${resource.filePath}.buffers[${bufferIndex}].uri`,
       );
       resource.dataUriMetadata.set(bufferIndex, metadata);
-      record = { bytes: Buffer.from(bytes), dataUri: true };
+      record = { bytes, dataUri: true };
     } else {
       const bufferPath = resolveLocalUri(
         path.dirname(resource.filePath),
@@ -205,7 +205,7 @@ function loadResourceBuffer(resource, bufferIndex) {
     }
   } else if (resource.type === 'glb' && bufferIndex === 0) {
     record = {
-      bytes: Buffer.from(resource.embeddedBin || Buffer.alloc(0)),
+      bytes: resource.embeddedBin || Buffer.alloc(0),
       embedded: true,
     };
   } else {
@@ -322,7 +322,7 @@ function applyBufferReplacements(resource, bufferIndex, replacements) {
 
   replacements.forEach((replacement) => {
     parts.push(record.bytes.subarray(cursor, replacement.start));
-    parts.push(Buffer.from(replacement.bytes));
+    parts.push(replacement.bytes);
     cursor = replacement.end;
   });