3dtiles-inspector 0.2.5 → 0.2.7

package/CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on Keep a Changelog and this project follows Semantic Versio
 
 ## [Unreleased]
 
+## [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
+
+- Added realtime `camerapose` URL synchronization so shared viewer URLs can restore the current camera pose.
+
 ## [0.2.5] - 2026-05-05
 
 ### Fixed

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 isGaussianSplatNode(node) {
+  return node instanceof SplatMesh || isGaussianSplat(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 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();
@@ -68245,6 +68160,10 @@ function createFlyToController({
     }
     return true;
   }
+  function cancelCameraFlight() {
+    activeCameraFlight = null;
+    activeCameraFlightStatus = "";
+  }
   async function applyTilesSetPositionFromPointerEvent(event) {
     const coordinate = pickCoordinateFromPointerEvent(event);
     if (!coordinate) {
@@ -68309,6 +68228,7 @@ function createFlyToController({
   }
   return {
     applyTilesSetPositionFromPointerEvent,
+    cancelCameraFlight,
     frameTileset,
     getActiveEllipsoid,
     moveCameraToCoordinate,
@@ -68325,6 +68245,148 @@ var init_flyTo = __esm({
   }
 });
 
+// src/viewer/navigation/cameraUrlPose.js
+function formatPoseNumber(value) {
+  const fixed = value.toFixed(9);
+  const trimmed = fixed.replace(/(\.\d*?[1-9])0+$/, "$1").replace(/\.0+$/, "");
+  return trimmed === "-0" ? "0" : trimmed;
+}
+function serializeCameraPose(camera) {
+  camera.updateMatrixWorld(true);
+  const values = [
+    camera.position.x,
+    camera.position.y,
+    camera.position.z,
+    camera.quaternion.x,
+    camera.quaternion.y,
+    camera.quaternion.z,
+    camera.quaternion.w
+  ];
+  if (camera.isOrthographicCamera) {
+    values.push(camera.zoom);
+  }
+  if (!values.every(Number.isFinite)) {
+    return null;
+  }
+  return values.map(formatPoseNumber).join(CAMERA_POSE_VALUE_SEPARATOR);
+}
+function getCameraPoseParam(url) {
+  return url.searchParams.get(CAMERA_POSE_PARAM) ?? url.searchParams.get(CAMERA_POSE_ALIAS_PARAM);
+}
+function parseCameraPose(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const parts = value.trim().split(/[,_\s]+/).filter(Boolean);
+  if (parts.length !== CAMERA_POSE_COMPONENT_COUNT && parts.length !== CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM) {
+    return null;
+  }
+  const values = parts.map(Number);
+  if (!values.every(Number.isFinite)) {
+    return null;
+  }
+  const quaternionLength = Math.hypot(
+    values[3],
+    values[4],
+    values[5],
+    values[6]
+  );
+  if (quaternionLength <= 1e-12) {
+    return null;
+  }
+  const zoom = values.length === CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM ? values[7] : null;
+  if (zoom !== null && zoom <= 0) {
+    return null;
+  }
+  return {
+    position: values.slice(0, 3),
+    quaternion: values.slice(3, 7),
+    zoom
+  };
+}
+function replaceCameraPoseUrl(serializedPose) {
+  const url = new URL(window.location.href);
+  url.searchParams.delete(CAMERA_POSE_ALIAS_PARAM);
+  url.searchParams.set(CAMERA_POSE_PARAM, serializedPose);
+  window.history.replaceState(window.history.state, "", url.href);
+}
+function getInvalidCameraPoseMessage() {
+  return "Invalid camerapose URL parameter ignored. Expected x_y_z_qx_qy_qz_qw.";
+}
+function createCameraUrlPoseController({
+  camera,
+  cameraController,
+  setStatus
+}) {
+  let lastSerializedPose = null;
+  let lastUrlWriteTime = 0;
+  function applyPose(pose) {
+    camera.position.fromArray(pose.position);
+    camera.quaternion.fromArray(pose.quaternion).normalize();
+    if (pose.zoom !== null && camera.isOrthographicCamera) {
+      camera.zoom = Math.max(pose.zoom, 1e-6);
+      camera.updateProjectionMatrix();
+    }
+    camera.updateMatrixWorld(true);
+    cameraController.setCamera(camera);
+  }
+  function applyFromUrl({ showStatus = false } = {}) {
+    const url = new URL(window.location.href);
+    const value = getCameraPoseParam(url);
+    if (value === null) {
+      return false;
+    }
+    const pose = parseCameraPose(value);
+    if (!pose) {
+      if (showStatus && setStatus) {
+        setStatus(getInvalidCameraPoseMessage(), true);
+      }
+      return false;
+    }
+    applyPose(pose);
+    lastSerializedPose = serializeCameraPose(camera);
+    lastUrlWriteTime = performance.now();
+    if (lastSerializedPose) {
+      replaceCameraPoseUrl(lastSerializedPose);
+    }
+    if (showStatus && setStatus) {
+      setStatus("Applied camera pose from URL.");
+    }
+    return true;
+  }
+  function flush() {
+    const serializedPose = serializeCameraPose(camera);
+    if (!serializedPose || serializedPose === lastSerializedPose) {
+      return;
+    }
+    replaceCameraPoseUrl(serializedPose);
+    lastSerializedPose = serializedPose;
+    lastUrlWriteTime = performance.now();
+  }
+  function update(time = performance.now()) {
+    if (time - lastUrlWriteTime < CAMERA_POSE_UPDATE_INTERVAL_MS) {
+      return;
+    }
+    flush();
+  }
+  return {
+    applyFromUrl,
+    flush,
+    update
+  };
+}
+var CAMERA_POSE_PARAM, CAMERA_POSE_ALIAS_PARAM, CAMERA_POSE_COMPONENT_COUNT, CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM, CAMERA_POSE_UPDATE_INTERVAL_MS, CAMERA_POSE_VALUE_SEPARATOR;
+var init_cameraUrlPose = __esm({
+  "src/viewer/navigation/cameraUrlPose.js"() {
+    CAMERA_POSE_PARAM = "camerapose";
+    CAMERA_POSE_ALIAS_PARAM = "cameraPose";
+    CAMERA_POSE_COMPONENT_COUNT = 7;
+    CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM = 8;
+    CAMERA_POSE_UPDATE_INTERVAL_MS = 100;
+    CAMERA_POSE_VALUE_SEPARATOR = "_";
+  }
+});
+
 // src/viewer/screenSelection/state.js
 function clamp3(value, min, max) {
   return Math.min(max, Math.max(min, value));
@@ -71052,6 +71114,7 @@ var require_app = __commonJS({
     init_shutdown();
     init_setPositionController();
     init_flyTo();
+    init_cameraUrlPose();
     init_cropController();
     init_rootTransformController();
     init_transformModeController();
@@ -71256,6 +71319,14 @@ var require_app = __commonJS({
       getTiles: () => tiles,
       getTilesetBoundingSphere
     });
+    var cameraUrlPose = createCameraUrlPoseController({
+      camera,
+      cameraController,
+      setStatus
+    });
+    var appliedInitialCameraPose = cameraUrlPose.applyFromUrl({
+      showStatus: true
+    });
     setPositionController = createSetPositionController({
       cameraController,
       maxClickDistanceSq: SET_POSITION_CLICK_MAX_DISTANCE_SQ,
@@ -71496,10 +71567,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(
@@ -71559,10 +71631,19 @@ var require_app = __commonJS({
       renderer,
       setStatus
     });
-    loadTileset(TILESET_URL);
+    window.addEventListener("popstate", () => {
+      if (cameraUrlPose.applyFromUrl({ showStatus: true })) {
+        flyTo2.cancelCameraFlight();
+        cancelPositionPickModes();
+      }
+    });
+    window.addEventListener("pagehide", cameraUrlPose.flush);
+    cameraController.addEventListener("finish", cameraUrlPose.flush);
+    loadTileset(TILESET_URL, { frameOnLoad: !appliedInitialCameraPose });
     function frame() {
       cameraController.update();
       flyTo2.update();
+      cameraUrlPose.update();
       rootTransform.flush();
       globeController.update();
       tiles?.update();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3dtiles-inspector",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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/index.js

@@ -6,6 +6,7 @@ const { assertPathInsideRoot } = require('./gltfResource');
 const { getRootUpRotationMatrix } = require('./gaussianPrimitives');
 const {
   collectCandidateSplatResources,
+  deleteOrphanedSplatResources,
   readTilesetJson,
   traverseTileset,
 } = require('./traversal');
@@ -35,6 +36,8 @@ async function deleteSplatsInNormalizedSelections(
   if (normalizedScreenSelections.length === 0) {
     return {
       deletedSplats: 0,
+      deletedSplatFiles: 0,
+      failedSplatFileDeletes: 0,
       processedSplatResources: 0,
     };
   }
@@ -45,11 +48,12 @@ async function deleteSplatsInNormalizedSelections(
 
   const { THREE } = await getSplatCropModules();
   const rootTileset = readTilesetJson(tilesetPath);
-  const totalResources = collectCandidateSplatResources({
+  const initialResourcePaths = collectCandidateSplatResources({
     rootDir,
     tileset: rootTileset,
     tilesetPath,
-  }).size;
+  });
+  const totalResources = initialResourcePaths.size;
   if (typeof onProgress === 'function') {
     const readStreamHint = tileReadStreamsClosed
       ? ' Tile read streams closed.'
@@ -77,7 +81,7 @@ async function deleteSplatsInNormalizedSelections(
   const workerPool = new SplatCropWorkerPool(SPLAT_CROP_WORKER_COUNT);
 
   try {
-    return await traverseTileset({
+    const traversalResult = await traverseTileset({
       THREE,
       tilesetPath,
       tileset: rootTileset,
@@ -102,6 +106,20 @@ async function deleteSplatsInNormalizedSelections(
       resourceLocks: new Map(),
       workerPool,
     });
+    const remainingResourcePaths = collectCandidateSplatResources({
+      rootDir,
+      tilesetPath,
+    });
+    const cleanupResult = await deleteOrphanedSplatResources({
+      initialResourcePaths,
+      remainingResourcePaths,
+      rootDir,
+    });
+    return {
+      ...traversalResult,
+      deletedSplatFiles: cleanupResult.deletedFiles.length,
+      failedSplatFileDeletes: cleanupResult.failedFiles.length,
+    };
   } finally {
     await workerPool.close();
   }

package/src/server/splatCrop/traversal.js

@@ -20,6 +20,7 @@ const {
   hasNonGaussianScenePrimitives,
   hasScenePrimitives,
   removeMeshPrimitives,
+  updateGaussianPrimitiveAccessorCounts,
 } = require('./gaussianPrimitives');
 
 function getContentSlots(tile) {
@@ -399,6 +400,126 @@ function collectCandidateSplatResources({
   return resourcePaths;
 }
 
+function collectLocalGltfBufferPaths(filePath, rootDir) {
+  const bufferPaths = new Set();
+  if (path.extname(filePath).toLowerCase() !== '.gltf') {
+    return bufferPaths;
+  }
+  if (!fs.existsSync(filePath)) {
+    return bufferPaths;
+  }
+
+  const json = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  const buffers = Array.isArray(json.buffers) ? json.buffers : [];
+  const resourceDir = path.dirname(filePath);
+  buffers.forEach((buffer, index) => {
+    const uri = buffer?.uri;
+    if (
+      typeof uri !== 'string' ||
+      uri.length === 0 ||
+      /^data:/i.test(uri) ||
+      isRemoteOrProtocolUri(uri)
+    ) {
+      return;
+    }
+
+    bufferPaths.add(
+      resolveLocalUri(
+        resourceDir,
+        rootDir,
+        uri,
+        `${filePath}.buffers[${index}].uri`,
+      ),
+    );
+  });
+  return bufferPaths;
+}
+
+function collectReferencedGltfBufferPaths(resourcePaths, rootDir) {
+  const bufferPaths = new Set();
+  resourcePaths.forEach((resourcePath) => {
+    collectLocalGltfBufferPaths(resourcePath, rootDir).forEach((bufferPath) => {
+      bufferPaths.add(bufferPath);
+    });
+  });
+  return bufferPaths;
+}
+
+async function deleteFileIfSafe(filePath, rootDir) {
+  const resolvedPath = assertPathInsideRoot(
+    filePath,
+    rootDir,
+    'Orphaned splat resource path',
+  );
+  let stats;
+  try {
+    stats = await fs.promises.stat(resolvedPath);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      return { deleted: false };
+    }
+    return {
+      deleted: false,
+      error: err && err.message ? err.message : String(err),
+    };
+  }
+
+  if (!stats.isFile()) {
+    return { deleted: false };
+  }
+
+  try {
+    await fs.promises.unlink(resolvedPath);
+    return { deleted: true };
+  } catch (err) {
+    return {
+      deleted: false,
+      error: err && err.message ? err.message : String(err),
+    };
+  }
+}
+
+async function deleteOrphanedSplatResources({
+  initialResourcePaths,
+  remainingResourcePaths,
+  rootDir,
+}) {
+  const remainingBuffers = collectReferencedGltfBufferPaths(
+    remainingResourcePaths,
+    rootDir,
+  );
+  const deletePaths = new Set();
+
+  initialResourcePaths.forEach((resourcePath) => {
+    if (remainingResourcePaths.has(resourcePath)) {
+      return;
+    }
+
+    deletePaths.add(resourcePath);
+    collectLocalGltfBufferPaths(resourcePath, rootDir).forEach((bufferPath) => {
+      if (
+        !remainingResourcePaths.has(bufferPath) &&
+        !remainingBuffers.has(bufferPath)
+      ) {
+        deletePaths.add(bufferPath);
+      }
+    });
+  });
+
+  const deletedFiles = [];
+  const failedFiles = [];
+  for (const filePath of deletePaths) {
+    const result = await deleteFileIfSafe(filePath, rootDir);
+    if (result.deleted) {
+      deletedFiles.push(filePath);
+    } else if (result.error) {
+      failedFiles.push({ error: result.error, filePath });
+    }
+  }
+
+  return { deletedFiles, failedFiles };
+}
+
 function markSplatResourceProgress(context, resourcePath) {
   const progress = context.progress;
   if (
@@ -472,6 +593,7 @@ async function processGltfResource({
   const resourceBounds = createBounds();
   let hasResourceBounds = false;
   let deletedSplats = 0;
+  let modified = false;
   const rewriteTasks = [];
 
   for (const [bufferViewIndex, viewDescriptors] of byBufferView) {
@@ -511,6 +633,14 @@ async function processGltfResource({
       emptyDescriptors.push(...viewDescriptors);
       continue;
     }
+    if (Number.isInteger(rewrite.survivorCount)) {
+      modified =
+        updateGaussianPrimitiveAccessorCounts(
+          resource,
+          viewDescriptors,
+          rewrite.survivorCount,
+        ) > 0 || modified;
+    }
     if (!rewrite.bytes) {
       continue;
     }
@@ -526,7 +656,6 @@ async function processGltfResource({
     });
   }
 
-  let modified = false;
   if (emptyDescriptors.length > 0) {
     modified = removeMeshPrimitives(resource, emptyDescriptors) > 0 || modified;
   }
@@ -948,6 +1077,7 @@ async function traverseTileset({
 
 module.exports = {
   collectCandidateSplatResources,
+  deleteOrphanedSplatResources,
   readTilesetJson,
   traverseTileset,
 };

package/src/server/splatCrop/worker.js

@@ -344,10 +344,24 @@ async function rewriteSpzBytes({
     descriptors,
   );
   if (survivors.length === 0) {
-    return { bounds, bytes: null, deleted, empty: true };
+    return {
+      bounds,
+      bytes: null,
+      deleted,
+      empty: true,
+      splatCount: spz.numSplats,
+      survivorCount: 0,
+    };
   }
   if (deleted === 0) {
-    return { bounds, bytes: null, deleted: 0, empty: false };
+    return {
+      bounds,
+      bytes: null,
+      deleted: 0,
+      empty: false,
+      splatCount: spz.numSplats,
+      survivorCount: survivors.length,
+    };
   }
 
   return {
@@ -355,6 +369,8 @@ async function rewriteSpzBytes({
     bytes: await writeSurvivingSpzBytes(SpzWriter, spz, splatData, survivors),
     deleted,
     empty: false,
+    splatCount: spz.numSplats,
+    survivorCount: survivors.length,
   };
 }
 
@@ -380,6 +396,8 @@ parentPort.on('message', async (message) => {
           bytes,
           deleted: result.deleted,
           empty: result.empty,
+          splatCount: result.splatCount,
+          survivorCount: result.survivorCount,
         },
       },
       transferList,

package/src/server/splatCrop/workerPool.js

@@ -77,6 +77,8 @@ class SplatCropWorkerPool {
         bytes: result.bytes ? Buffer.from(result.bytes) : null,
         deleted: Number(result.deleted || 0),
         empty: !!result.empty,
+        splatCount: Number(result.splatCount || 0),
+        survivorCount: Number(result.survivorCount || 0),
       });
     }
 

package/src/viewer/app.js

@@ -17,6 +17,7 @@ import { bindViewerEvents } from './dom/events.js';
 import { createViewerShutdownRequester } from './io/shutdown.js';
 import { createSetPositionController } from './io/setPositionController.js';
 import { createFlyToController } from './navigation/flyTo.js';
+import { createCameraUrlPoseController } from './navigation/cameraUrlPose.js';
 import { createCropController } from './screenSelection/cropController.js';
 import { createRootTransformController } from './transform/rootTransformController.js';
 import { createTransformModeController } from './transform/transformModeController.js';
@@ -269,6 +270,15 @@ const flyTo = createFlyToController({
   getTilesetBoundingSphere,
 });
 
+const cameraUrlPose = createCameraUrlPoseController({
+  camera,
+  cameraController,
+  setStatus,
+});
+const appliedInitialCameraPose = cameraUrlPose.applyFromUrl({
+  showStatus: true,
+});
+
 setPositionController = createSetPositionController({
   cameraController,
   maxClickDistanceSq: SET_POSITION_CLICK_MAX_DISTANCE_SQ,
@@ -540,10 +550,11 @@ async function saveTransform() {
       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(
@@ -605,11 +616,21 @@ bindViewerEvents({
   setStatus,
 });
 
-loadTileset(TILESET_URL);
+window.addEventListener('popstate', () => {
+  if (cameraUrlPose.applyFromUrl({ showStatus: true })) {
+    flyTo.cancelCameraFlight();
+    cancelPositionPickModes();
+  }
+});
+window.addEventListener('pagehide', cameraUrlPose.flush);
+cameraController.addEventListener('finish', cameraUrlPose.flush);
+
+loadTileset(TILESET_URL, { frameOnLoad: !appliedInitialCameraPose });
 
 function frame() {
   cameraController.update();
   flyTo.update();
+  cameraUrlPose.update();
   rootTransform.flush();
   globeController.update();
   tiles?.update();

package/src/viewer/navigation/cameraUrlPose.js

@@ -0,0 +1,172 @@
+const CAMERA_POSE_PARAM = 'camerapose';
+const CAMERA_POSE_ALIAS_PARAM = 'cameraPose';
+const CAMERA_POSE_COMPONENT_COUNT = 7;
+const CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM = 8;
+const CAMERA_POSE_UPDATE_INTERVAL_MS = 100;
+const CAMERA_POSE_VALUE_SEPARATOR = '_';
+
+function formatPoseNumber(value) {
+  const fixed = value.toFixed(9);
+  const trimmed = fixed
+    .replace(/(\.\d*?[1-9])0+$/, '$1')
+    .replace(/\.0+$/, '');
+
+  return trimmed === '-0' ? '0' : trimmed;
+}
+
+function serializeCameraPose(camera) {
+  camera.updateMatrixWorld(true);
+
+  const values = [
+    camera.position.x,
+    camera.position.y,
+    camera.position.z,
+    camera.quaternion.x,
+    camera.quaternion.y,
+    camera.quaternion.z,
+    camera.quaternion.w,
+  ];
+
+  if (camera.isOrthographicCamera) {
+    values.push(camera.zoom);
+  }
+
+  if (!values.every(Number.isFinite)) {
+    return null;
+  }
+
+  return values.map(formatPoseNumber).join(CAMERA_POSE_VALUE_SEPARATOR);
+}
+
+function getCameraPoseParam(url) {
+  return (
+    url.searchParams.get(CAMERA_POSE_PARAM) ??
+    url.searchParams.get(CAMERA_POSE_ALIAS_PARAM)
+  );
+}
+
+function parseCameraPose(value) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    return null;
+  }
+
+  const parts = value.trim().split(/[,_\s]+/).filter(Boolean);
+  if (
+    parts.length !== CAMERA_POSE_COMPONENT_COUNT &&
+    parts.length !== CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM
+  ) {
+    return null;
+  }
+
+  const values = parts.map(Number);
+  if (!values.every(Number.isFinite)) {
+    return null;
+  }
+
+  const quaternionLength = Math.hypot(
+    values[3],
+    values[4],
+    values[5],
+    values[6],
+  );
+  if (quaternionLength <= 1e-12) {
+    return null;
+  }
+
+  const zoom = values.length === CAMERA_POSE_COMPONENT_COUNT_WITH_ZOOM
+    ? values[7]
+    : null;
+  if (zoom !== null && zoom <= 0) {
+    return null;
+  }
+
+  return {
+    position: values.slice(0, 3),
+    quaternion: values.slice(3, 7),
+    zoom,
+  };
+}
+
+function replaceCameraPoseUrl(serializedPose) {
+  const url = new URL(window.location.href);
+  url.searchParams.delete(CAMERA_POSE_ALIAS_PARAM);
+  url.searchParams.set(CAMERA_POSE_PARAM, serializedPose);
+  window.history.replaceState(window.history.state, '', url.href);
+}
+
+function getInvalidCameraPoseMessage() {
+  return 'Invalid camerapose URL parameter ignored. Expected x_y_z_qx_qy_qz_qw.';
+}
+
+export function createCameraUrlPoseController({
+  camera,
+  cameraController,
+  setStatus,
+}) {
+  let lastSerializedPose = null;
+  let lastUrlWriteTime = 0;
+
+  function applyPose(pose) {
+    camera.position.fromArray(pose.position);
+    camera.quaternion.fromArray(pose.quaternion).normalize();
+
+    if (pose.zoom !== null && camera.isOrthographicCamera) {
+      camera.zoom = Math.max(pose.zoom, 1e-6);
+      camera.updateProjectionMatrix();
+    }
+
+    camera.updateMatrixWorld(true);
+    cameraController.setCamera(camera);
+  }
+
+  function applyFromUrl({ showStatus = false } = {}) {
+    const url = new URL(window.location.href);
+    const value = getCameraPoseParam(url);
+    if (value === null) {
+      return false;
+    }
+
+    const pose = parseCameraPose(value);
+    if (!pose) {
+      if (showStatus && setStatus) {
+        setStatus(getInvalidCameraPoseMessage(), true);
+      }
+      return false;
+    }
+
+    applyPose(pose);
+    lastSerializedPose = serializeCameraPose(camera);
+    lastUrlWriteTime = performance.now();
+    if (lastSerializedPose) {
+      replaceCameraPoseUrl(lastSerializedPose);
+    }
+    if (showStatus && setStatus) {
+      setStatus('Applied camera pose from URL.');
+    }
+    return true;
+  }
+
+  function flush() {
+    const serializedPose = serializeCameraPose(camera);
+    if (!serializedPose || serializedPose === lastSerializedPose) {
+      return;
+    }
+
+    replaceCameraPoseUrl(serializedPose);
+    lastSerializedPose = serializedPose;
+    lastUrlWriteTime = performance.now();
+  }
+
+  function update(time = performance.now()) {
+    if (time - lastUrlWriteTime < CAMERA_POSE_UPDATE_INTERVAL_MS) {
+      return;
+    }
+    flush();
+  }
+
+  return {
+    applyFromUrl,
+    flush,
+    update,
+  };
+}

package/src/viewer/navigation/flyTo.js

@@ -133,6 +133,11 @@ export function createFlyToController({
     return true;
   }
 
+  function cancelCameraFlight() {
+    activeCameraFlight = null;
+    activeCameraFlightStatus = '';
+  }
+
   async function applyTilesSetPositionFromPointerEvent(event) {
     const coordinate = pickCoordinateFromPointerEvent(event);
     if (!coordinate) {
@@ -204,6 +209,7 @@ export function createFlyToController({
 
   return {
     applyTilesSetPositionFromPointerEvent,
+    cancelCameraFlight,
     frameTileset,
     getActiveEllipsoid,
     moveCameraToCoordinate,