3dtiles-inspector 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on Keep a Changelog and this project follows Semantic Versio
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-04-27
+
+### Changed
+
+- Changed `Layer Multiplier` to scale each tile's geometric-error difference from its leaf baseline instead of applying a depth-based multiplier.
+- Expanded the `Layer Multiplier` range to `1/8x` through `8x`.
+
+## [0.1.5] - 2026-04-27
+
+### Added
+
+- Added an LOD `Layer Multiplier` slider to scale geometric errors progressively by distance from leaf tiles.
+
+### Changed
+
+- Tightened inspector toolbar spacing and LOD slider value labels.
+
 ## [0.1.4] - 2026-04-25
 
 ### Changed

package/README.md

@@ -82,6 +82,7 @@ const {
 - `Set Position` to click the globe, terrain, or loaded tiles and place the tileset there
 - `Terrain` to toggle Cesium World Terrain while keeping satellite imagery
 - `Geometric Error` scaling from `1/16x` to `16x`
+- `Layer Multiplier` scaling from `1/8x` to `8x` for each tile's geometric-error difference from its leaf baseline
 - `Save` to persist the updated root transform and geometric-error scale back to disk
 
 If `build_summary.json` exists next to the root tileset, `Save` also updates:
@@ -90,6 +91,7 @@ If `build_summary.json` exists next to the root tileset, `Save` also updates:
 - `root_transform_source`
 - `root_coordinate`
 - `viewer_geometric_error_scale`
+- `viewer_geometric_error_layer_scale`
 
 ## Package Surface
 

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

@@ -65484,12 +65484,21 @@ var geometricErrorScaleInput = document.getElementById(
   "geometric-error-scale"
 );
 var geometricErrorValueEl = document.getElementById("geometric-error-value");
+var geometricErrorLayerScaleInput = document.getElementById(
+  "geometric-error-layer-scale"
+);
+var geometricErrorLayerValueEl = document.getElementById(
+  "geometric-error-layer-value"
+);
 var setPositionButton = document.getElementById("set-position");
 var resetButton = document.getElementById("reset");
 var saveButton = document.getElementById("save");
 var GEOMETRIC_ERROR_SCALE_MIN_EXPONENT = -4;
 var GEOMETRIC_ERROR_SCALE_MAX_EXPONENT = 4;
 var GEOMETRIC_ERROR_SCALE_STEP = 0.1;
+var GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -3;
+var GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = 3;
+var GEOMETRIC_ERROR_LAYER_SCALE_STEP = 0.1;
 var DEFAULT_ERROR_TARGET = 16;
 var DEFAULT_TERRAIN_ERROR_TARGET = 16;
 var RUNTIME_STATS_UPDATE_INTERVAL_MS = 250;
@@ -65801,12 +65810,16 @@ var savedRootInverseMatrix = new Matrix4();
 var pointerCoords = new Vector2();
 var pickRaycaster = new Raycaster();
 var pickTargets = [];
+var originalTileGeometricErrors = /* @__PURE__ */ new WeakMap();
 var tiles = null;
 var toolbarVisible = true;
 var activeTransformMode = null;
 var geometricErrorScaleExponent = 0;
 var geometricErrorScale = 1;
 var lastSavedGeometricErrorScale = 1;
+var geometricErrorLayerScaleExponent = 0;
+var geometricErrorLayerScale = 1;
+var lastSavedGeometricErrorLayerScale = 1;
 var lastSavedMatrix = new Matrix4();
 var savedRootMatrix = new Matrix4();
 var savedRootMatrixPromise = Promise.resolve();
@@ -65831,9 +65844,77 @@ function updateGeometricErrorScaleDisplay() {
     geometricErrorScale
   )}`;
 }
+function updateGeometricErrorLayerScaleDisplay() {
+  geometricErrorLayerValueEl.textContent = `x${formatGeometricErrorScale(
+    geometricErrorLayerScale
+  )}`;
+}
 function getEffectiveGeometricErrorScale() {
   return lastSavedGeometricErrorScale * geometricErrorScale;
 }
+function getEffectiveGeometricErrorLayerScale() {
+  return lastSavedGeometricErrorLayerScale * geometricErrorLayerScale;
+}
+function getOriginalTileGeometricError(tile) {
+  if (!tile || typeof tile !== "object") {
+    return null;
+  }
+  if (!originalTileGeometricErrors.has(tile)) {
+    const number = Number(tile.geometricError);
+    if (!Number.isFinite(number)) {
+      return null;
+    }
+    originalTileGeometricErrors.set(tile, number);
+  }
+  return originalTileGeometricErrors.get(tile);
+}
+function getKnownTileLeafGeometricError(tile, visited = /* @__PURE__ */ new Set()) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  if (originalGeometricError === null || !tile || typeof tile !== "object" || visited.has(tile)) {
+    return originalGeometricError;
+  }
+  visited.add(tile);
+  let leafGeometricError = null;
+  const children = Array.isArray(tile.children) ? tile.children : [];
+  for (const child of children) {
+    const childLeafGeometricError = getKnownTileLeafGeometricError(
+      child,
+      visited
+    );
+    if (childLeafGeometricError !== null) {
+      leafGeometricError = leafGeometricError === null ? childLeafGeometricError : Math.min(leafGeometricError, childLeafGeometricError);
+    }
+  }
+  visited.delete(tile);
+  return leafGeometricError === null ? originalGeometricError : leafGeometricError;
+}
+function applyGeometricErrorLayerScaleToTile(tile) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  const leafGeometricError = getKnownTileLeafGeometricError(tile);
+  if (originalGeometricError === null || leafGeometricError === null) {
+    return;
+  }
+  tile.geometricError = leafGeometricError + (originalGeometricError - leafGeometricError) * getEffectiveGeometricErrorLayerScale();
+}
+function applyGeometricErrorLayerScaleToTileset() {
+  if (!tiles) {
+    return;
+  }
+  tiles.traverse(
+    (tile) => {
+      applyGeometricErrorLayerScaleToTile(tile);
+      return false;
+    },
+    null,
+    false
+  );
+}
+var geometricErrorLayerScalePlugin = {
+  name: "GeometricErrorLayerScalePlugin",
+  preprocessNode(tile) {
+    applyGeometricErrorLayerScaleToTile(tile);
+  }
+};
 function getGaussianMeshSplatCount(mesh) {
   if (!mesh || typeof mesh !== "object") {
     return 0;
@@ -65898,6 +65979,19 @@ function setGeometricErrorScaleExponent(exponent) {
   updateGeometricErrorScaleDisplay();
   updateTilesetErrorTarget();
 }
+function setGeometricErrorLayerScaleExponent(exponent) {
+  geometricErrorLayerScaleExponent = clamp2(
+    Number(exponent),
+    GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT,
+    GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT
+  );
+  geometricErrorLayerScale = exponentToGeometricErrorScale(
+    geometricErrorLayerScaleExponent
+  );
+  geometricErrorLayerScaleInput.value = geometricErrorLayerScaleExponent.toFixed(1);
+  updateGeometricErrorLayerScaleDisplay();
+  applyGeometricErrorLayerScaleToTileset();
+}
 function syncTerrainButton() {
   terrainButton.classList.toggle("active", terrainEnabled);
   terrainLight.visible = terrainEnabled;
@@ -65979,7 +66073,15 @@ function toggleTransformMode(mode) {
 geometricErrorScaleInput.min = String(GEOMETRIC_ERROR_SCALE_MIN_EXPONENT);
 geometricErrorScaleInput.max = String(GEOMETRIC_ERROR_SCALE_MAX_EXPONENT);
 geometricErrorScaleInput.step = String(GEOMETRIC_ERROR_SCALE_STEP);
+geometricErrorLayerScaleInput.min = String(
+  GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT
+);
+geometricErrorLayerScaleInput.max = String(
+  GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT
+);
+geometricErrorLayerScaleInput.step = String(GEOMETRIC_ERROR_LAYER_SCALE_STEP);
 setGeometricErrorScaleExponent(geometricErrorScaleExponent);
+setGeometricErrorLayerScaleExponent(geometricErrorLayerScaleExponent);
 setTerrainEnabled(terrainEnabled);
 setTransformMode(activeTransformMode);
 syncToolbarVisibility();
@@ -66473,7 +66575,9 @@ function loadTileset(url) {
   updateRuntimeStats(true);
   resetEditableGroup();
   lastSavedGeometricErrorScale = 1;
+  lastSavedGeometricErrorLayerScale = 1;
   setGeometricErrorScaleExponent(0);
+  setGeometricErrorLayerScaleExponent(0);
   savedRootMatrix.identity();
   savedRootMatrixLoadError = null;
   savedRootMatrixPromise = refreshSavedRootMatrix(url).then(
@@ -66496,7 +66600,16 @@ function loadTileset(url) {
   next.registerPlugin(new go());
   next.registerPlugin(new To());
   next.registerPlugin(new w2());
-  next.registerPlugin(new GaussianSplatPlugin({ renderer, scene }));
+  next.registerPlugin(geometricErrorLayerScalePlugin);
+  next.registerPlugin(
+    new GaussianSplatPlugin({
+      renderer,
+      scene,
+      sparkRendererOptions: {
+        accumExtSplats: true
+      }
+    })
+  );
   debugTilesPlugin = new Oo({
     displayBoxBounds: showBoundingVolume,
     displaySphereBounds: showBoundingVolume,
@@ -66543,6 +66656,7 @@ function loadTileset(url) {
       setStatus("Tileset ready.");
     }
   };
+  next.addEventListener("load-tileset", applyGeometricErrorLayerScaleToTileset);
   next.addEventListener("load-tile-set", tryFrame);
   next.addEventListener("load-tileset", tryFrame);
 }
@@ -66554,6 +66668,8 @@ async function saveTransform() {
   const incrementalMatrix = currentMatrix.clone().multiply(lastSavedMatrix.clone().invert());
   const incrementalGeometricErrorScale = geometricErrorScale;
   const savedGeometricErrorScale = getEffectiveGeometricErrorScale();
+  const incrementalGeometricErrorLayerScale = geometricErrorLayerScale;
+  const savedGeometricErrorLayerScale = getEffectiveGeometricErrorLayerScale();
   try {
     const response = await fetch(SAVE_URL, {
       method: "POST",
@@ -66561,6 +66677,7 @@ async function saveTransform() {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
+        geometricErrorLayerScale: incrementalGeometricErrorLayerScale,
         geometricErrorScale: incrementalGeometricErrorScale,
         transform: incrementalMatrix.toArray()
       })
@@ -66591,13 +66708,17 @@ async function saveTransform() {
       }
     }
     lastSavedGeometricErrorScale = savedGeometricErrorScale;
+    lastSavedGeometricErrorLayerScale = savedGeometricErrorLayerScale;
     lastSavedMatrix.copy(currentMatrix);
     setGeometricErrorScaleExponent(0);
+    setGeometricErrorLayerScaleExponent(0);
     syncTransformHandleFromTilesTransform();
     syncCoordinateInputsFromTilesTransform();
     setStatus(
-      `Saved transform and geometric-error scale x${formatGeometricErrorScale(
+      `Saved transform, geometric-error scale x${formatGeometricErrorScale(
         savedGeometricErrorScale
+      )}, and layer multiplier x${formatGeometricErrorScale(
+        savedGeometricErrorLayerScale
       )} to ${ROOT_TILESET_LABEL} and build_summary.json.`
     );
   } catch (err2) {
@@ -66638,6 +66759,16 @@ geometricErrorScaleInput.addEventListener("change", () => {
     )}.`
   );
 });
+geometricErrorLayerScaleInput.addEventListener("input", () => {
+  setGeometricErrorLayerScaleExponent(geometricErrorLayerScaleInput.value);
+});
+geometricErrorLayerScaleInput.addEventListener("change", () => {
+  setStatus(
+    `Geometric-error layer multiplier set to x${formatGeometricErrorScale(
+      geometricErrorLayerScale
+    )}.`
+  );
+});
 moveToTilesButton.addEventListener("click", moveCameraToTiles);
 moveCameraToCoordinateButton.addEventListener("click", moveCameraToCoordinate);
 moveTilesToCoordinateButton.addEventListener("click", moveTilesToCoordinate);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3dtiles-inspector",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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",

package/src/viewer/app.js

@@ -100,12 +100,21 @@ const geometricErrorScaleInput = document.getElementById(
   'geometric-error-scale',
 );
 const geometricErrorValueEl = document.getElementById('geometric-error-value');
+const geometricErrorLayerScaleInput = document.getElementById(
+  'geometric-error-layer-scale',
+);
+const geometricErrorLayerValueEl = document.getElementById(
+  'geometric-error-layer-value',
+);
 const setPositionButton = document.getElementById('set-position');
 const resetButton = document.getElementById('reset');
 const saveButton = document.getElementById('save');
 const GEOMETRIC_ERROR_SCALE_MIN_EXPONENT = -4;
 const GEOMETRIC_ERROR_SCALE_MAX_EXPONENT = 4;
 const GEOMETRIC_ERROR_SCALE_STEP = 0.1;
+const GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -3;
+const GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = 3;
+const GEOMETRIC_ERROR_LAYER_SCALE_STEP = 0.1;
 const DEFAULT_ERROR_TARGET = 16;
 const DEFAULT_TERRAIN_ERROR_TARGET = 16;
 const RUNTIME_STATS_UPDATE_INTERVAL_MS = 250;
@@ -470,12 +479,16 @@ const savedRootInverseMatrix = new Matrix4();
 const pointerCoords = new Vector2();
 const pickRaycaster = new Raycaster();
 const pickTargets = [];
+const originalTileGeometricErrors = new WeakMap();
 let tiles = null;
 let toolbarVisible = true;
 let activeTransformMode = null;
 let geometricErrorScaleExponent = 0;
 let geometricErrorScale = 1;
 let lastSavedGeometricErrorScale = 1;
+let geometricErrorLayerScaleExponent = 0;
+let geometricErrorLayerScale = 1;
+let lastSavedGeometricErrorLayerScale = 1;
 let lastSavedMatrix = new Matrix4();
 const savedRootMatrix = new Matrix4();
 let savedRootMatrixPromise = Promise.resolve();
@@ -505,10 +518,103 @@ function updateGeometricErrorScaleDisplay() {
   )}`;
 }
 
+function updateGeometricErrorLayerScaleDisplay() {
+  geometricErrorLayerValueEl.textContent = `x${formatGeometricErrorScale(
+    geometricErrorLayerScale,
+  )}`;
+}
+
 function getEffectiveGeometricErrorScale() {
   return lastSavedGeometricErrorScale * geometricErrorScale;
 }
 
+function getEffectiveGeometricErrorLayerScale() {
+  return lastSavedGeometricErrorLayerScale * geometricErrorLayerScale;
+}
+
+function getOriginalTileGeometricError(tile) {
+  if (!tile || typeof tile !== 'object') {
+    return null;
+  }
+
+  if (!originalTileGeometricErrors.has(tile)) {
+    const number = Number(tile.geometricError);
+    if (!Number.isFinite(number)) {
+      return null;
+    }
+    originalTileGeometricErrors.set(tile, number);
+  }
+
+  return originalTileGeometricErrors.get(tile);
+}
+
+function getKnownTileLeafGeometricError(tile, visited = new Set()) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  if (
+    originalGeometricError === null ||
+    !tile ||
+    typeof tile !== 'object' ||
+    visited.has(tile)
+  ) {
+    return originalGeometricError;
+  }
+
+  visited.add(tile);
+  let leafGeometricError = null;
+  const children = Array.isArray(tile.children) ? tile.children : [];
+  for (const child of children) {
+    const childLeafGeometricError = getKnownTileLeafGeometricError(
+      child,
+      visited,
+    );
+    if (childLeafGeometricError !== null) {
+      leafGeometricError =
+        leafGeometricError === null
+          ? childLeafGeometricError
+          : Math.min(leafGeometricError, childLeafGeometricError);
+    }
+  }
+  visited.delete(tile);
+  return leafGeometricError === null
+    ? originalGeometricError
+    : leafGeometricError;
+}
+
+function applyGeometricErrorLayerScaleToTile(tile) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  const leafGeometricError = getKnownTileLeafGeometricError(tile);
+  if (originalGeometricError === null || leafGeometricError === null) {
+    return;
+  }
+
+  tile.geometricError =
+    leafGeometricError +
+    (originalGeometricError - leafGeometricError) *
+      getEffectiveGeometricErrorLayerScale();
+}
+
+function applyGeometricErrorLayerScaleToTileset() {
+  if (!tiles) {
+    return;
+  }
+
+  tiles.traverse(
+    (tile) => {
+      applyGeometricErrorLayerScaleToTile(tile);
+      return false;
+    },
+    null,
+    false,
+  );
+}
+
+const geometricErrorLayerScalePlugin = {
+  name: 'GeometricErrorLayerScalePlugin',
+  preprocessNode(tile) {
+    applyGeometricErrorLayerScaleToTile(tile);
+  },
+};
+
 function getGaussianMeshSplatCount(mesh) {
   if (!mesh || typeof mesh !== 'object') {
     return 0;
@@ -605,6 +711,21 @@ function setGeometricErrorScaleExponent(exponent) {
   updateTilesetErrorTarget();
 }
 
+function setGeometricErrorLayerScaleExponent(exponent) {
+  geometricErrorLayerScaleExponent = clamp(
+    Number(exponent),
+    GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT,
+    GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT,
+  );
+  geometricErrorLayerScale = exponentToGeometricErrorScale(
+    geometricErrorLayerScaleExponent,
+  );
+  geometricErrorLayerScaleInput.value =
+    geometricErrorLayerScaleExponent.toFixed(1);
+  updateGeometricErrorLayerScaleDisplay();
+  applyGeometricErrorLayerScaleToTileset();
+}
+
 function syncTerrainButton() {
   terrainButton.classList.toggle('active', terrainEnabled);
   terrainLight.visible = terrainEnabled;
@@ -702,7 +823,15 @@ function toggleTransformMode(mode) {
 geometricErrorScaleInput.min = String(GEOMETRIC_ERROR_SCALE_MIN_EXPONENT);
 geometricErrorScaleInput.max = String(GEOMETRIC_ERROR_SCALE_MAX_EXPONENT);
 geometricErrorScaleInput.step = String(GEOMETRIC_ERROR_SCALE_STEP);
+geometricErrorLayerScaleInput.min = String(
+  GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT,
+);
+geometricErrorLayerScaleInput.max = String(
+  GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT,
+);
+geometricErrorLayerScaleInput.step = String(GEOMETRIC_ERROR_LAYER_SCALE_STEP);
 setGeometricErrorScaleExponent(geometricErrorScaleExponent);
+setGeometricErrorLayerScaleExponent(geometricErrorLayerScaleExponent);
 setTerrainEnabled(terrainEnabled);
 setTransformMode(activeTransformMode);
 syncToolbarVisibility();
@@ -1324,7 +1453,9 @@ function loadTileset(url) {
 
   resetEditableGroup();
   lastSavedGeometricErrorScale = 1;
+  lastSavedGeometricErrorLayerScale = 1;
   setGeometricErrorScaleExponent(0);
+  setGeometricErrorLayerScaleExponent(0);
   savedRootMatrix.identity();
   savedRootMatrixLoadError = null;
   savedRootMatrixPromise = refreshSavedRootMatrix(url).then(
@@ -1348,7 +1479,16 @@ function loadTileset(url) {
   next.registerPlugin(new TileCompressionPlugin());
   next.registerPlugin(new UnloadTilesPlugin());
   next.registerPlugin(new ImplicitTilingPlugin());
-  next.registerPlugin(new GaussianSplatPlugin({ renderer, scene }));
+  next.registerPlugin(geometricErrorLayerScalePlugin);
+  next.registerPlugin(
+    new GaussianSplatPlugin({
+      renderer,
+      scene,
+      sparkRendererOptions: {
+        accumExtSplats: true,
+      },
+    }),
+  );
   debugTilesPlugin = new DebugTilesPlugin({
     displayBoxBounds: showBoundingVolume,
     displaySphereBounds: showBoundingVolume,
@@ -1399,6 +1539,7 @@ function loadTileset(url) {
     }
   };
 
+  next.addEventListener('load-tileset', applyGeometricErrorLayerScaleToTileset);
   next.addEventListener('load-tile-set', tryFrame);
   next.addEventListener('load-tileset', tryFrame);
 }
@@ -1414,6 +1555,8 @@ async function saveTransform() {
     .multiply(lastSavedMatrix.clone().invert());
   const incrementalGeometricErrorScale = geometricErrorScale;
   const savedGeometricErrorScale = getEffectiveGeometricErrorScale();
+  const incrementalGeometricErrorLayerScale = geometricErrorLayerScale;
+  const savedGeometricErrorLayerScale = getEffectiveGeometricErrorLayerScale();
 
   try {
     const response = await fetch(SAVE_URL, {
@@ -1422,6 +1565,7 @@ async function saveTransform() {
         'Content-Type': 'application/json',
       },
       body: JSON.stringify({
+        geometricErrorLayerScale: incrementalGeometricErrorLayerScale,
         geometricErrorScale: incrementalGeometricErrorScale,
         transform: incrementalMatrix.toArray(),
       }),
@@ -1452,13 +1596,17 @@ async function saveTransform() {
       }
     }
     lastSavedGeometricErrorScale = savedGeometricErrorScale;
+    lastSavedGeometricErrorLayerScale = savedGeometricErrorLayerScale;
     lastSavedMatrix.copy(currentMatrix);
     setGeometricErrorScaleExponent(0);
+    setGeometricErrorLayerScaleExponent(0);
     syncTransformHandleFromTilesTransform();
     syncCoordinateInputsFromTilesTransform();
     setStatus(
-      `Saved transform and geometric-error scale x${formatGeometricErrorScale(
+      `Saved transform, geometric-error scale x${formatGeometricErrorScale(
         savedGeometricErrorScale,
+      )}, and layer multiplier x${formatGeometricErrorScale(
+        savedGeometricErrorLayerScale,
       )} to ${ROOT_TILESET_LABEL} and build_summary.json.`,
     );
   } catch (err) {
@@ -1506,6 +1654,16 @@ geometricErrorScaleInput.addEventListener('change', () => {
     )}.`,
   );
 });
+geometricErrorLayerScaleInput.addEventListener('input', () => {
+  setGeometricErrorLayerScaleExponent(geometricErrorLayerScaleInput.value);
+});
+geometricErrorLayerScaleInput.addEventListener('change', () => {
+  setStatus(
+    `Geometric-error layer multiplier set to x${formatGeometricErrorScale(
+      geometricErrorLayerScale,
+    )}.`,
+  );
+});
 moveToTilesButton.addEventListener('click', moveCameraToTiles);
 moveCameraToCoordinateButton.addEventListener('click', moveCameraToCoordinate);
 moveTilesToCoordinateButton.addEventListener('click', moveTilesToCoordinate);

package/src/viewer/session.js

@@ -174,7 +174,14 @@ function normalizePositiveFinite(value, name) {
   return number;
 }
 
-function scaleGeometricErrorValue(target, key, scale, label) {
+function scaleGeometricErrorValue(
+  target,
+  key,
+  geometricErrorScale,
+  geometricErrorLayerScale,
+  leafGeometricError,
+  label,
+) {
   if (target[key] == null) {
     return;
   }
@@ -184,10 +191,164 @@ function scaleGeometricErrorValue(target, key, scale, label) {
     throw new InspectorError(`${label} must be a finite number.`);
   }
 
-  target[key] = number * scale;
+  if (!Number.isFinite(leafGeometricError)) {
+    throw new InspectorError(`${label} leaf geometricError must be finite.`);
+  }
+
+  const adjusted =
+    leafGeometricError +
+    (number - leafGeometricError) * geometricErrorLayerScale;
+  const next = adjusted * geometricErrorScale;
+  if (!Number.isFinite(next)) {
+    throw new InspectorError(`${label} scaled value must be finite.`);
+  }
+
+  target[key] = next;
+}
+
+function assertTilesetPathInsideRoot(resolvedPath, rootDir) {
+  if (
+    resolvedPath !== rootDir &&
+    !resolvedPath.startsWith(`${rootDir}${path.sep}`)
+  ) {
+    throw new InspectorError(
+      `Nested tileset path escapes the viewer root: ${resolvedPath}`,
+    );
+  }
+}
+
+function getLocalExternalTilesetPaths(tile, baseDir) {
+  const paths = [];
+  if (!tile || typeof tile !== 'object') {
+    return paths;
+  }
+
+  if (tile.content && typeof tile.content === 'object') {
+    const filePath = getLocalJsonReferencePath(
+      baseDir,
+      tile.content.uri || tile.content.url,
+    );
+    if (filePath) {
+      paths.push(filePath);
+    }
+  }
+
+  if (Array.isArray(tile.contents)) {
+    tile.contents.forEach((entry) => {
+      if (entry && typeof entry === 'object') {
+        const filePath = getLocalJsonReferencePath(
+          baseDir,
+          entry.uri || entry.url,
+        );
+        if (filePath) {
+          paths.push(filePath);
+        }
+      }
+    });
+  }
+
+  return paths;
+}
+
+function getTilesetRootLeafGeometricError(
+  tilesetPath,
+  rootDir,
+  leafGeometricErrorCache,
+  stack,
+) {
+  const resolvedPath = path.resolve(tilesetPath);
+  if (leafGeometricErrorCache.has(resolvedPath)) {
+    return leafGeometricErrorCache.get(resolvedPath);
+  }
+
+  if (stack.has(resolvedPath)) {
+    return 0;
+  }
+
+  assertTilesetPathInsideRoot(resolvedPath, rootDir);
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new InspectorError(
+      `Referenced nested tileset does not exist: ${resolvedPath}`,
+    );
+  }
+
+  const tileset = readJsonFile(resolvedPath);
+  if (!tileset || typeof tileset !== 'object' || !tileset.root) {
+    throw new InspectorError(`${resolvedPath} must contain a root object.`);
+  }
+
+  stack.add(resolvedPath);
+  const leafGeometricError = getTileLeafGeometricError(
+    tileset.root,
+    path.dirname(resolvedPath),
+    rootDir,
+    leafGeometricErrorCache,
+    stack,
+  );
+  stack.delete(resolvedPath);
+  leafGeometricErrorCache.set(resolvedPath, leafGeometricError);
+  return leafGeometricError;
+}
+
+function getTileLeafGeometricError(
+  tile,
+  baseDir,
+  rootDir,
+  leafGeometricErrorCache,
+  stack,
+) {
+  if (!tile || typeof tile !== 'object') {
+    return 0;
+  }
+
+  const ownGeometricError = Number(tile.geometricError);
+  if (!Number.isFinite(ownGeometricError)) {
+    return 0;
+  }
+
+  let leafGeometricError = null;
+  if (Array.isArray(tile.children)) {
+    tile.children.forEach((child) => {
+      const childLeafGeometricError = getTileLeafGeometricError(
+        child,
+        baseDir,
+        rootDir,
+        leafGeometricErrorCache,
+        stack,
+      );
+      leafGeometricError =
+        leafGeometricError === null
+          ? childLeafGeometricError
+          : Math.min(leafGeometricError, childLeafGeometricError);
+    });
+  }
+
+  getLocalExternalTilesetPaths(tile, baseDir).forEach((childTilesetPath) => {
+    const childLeafGeometricError = getTilesetRootLeafGeometricError(
+      childTilesetPath,
+      rootDir,
+      leafGeometricErrorCache,
+      stack,
+    );
+    leafGeometricError =
+      leafGeometricError === null
+        ? childLeafGeometricError
+        : Math.min(leafGeometricError, childLeafGeometricError);
+  });
+
+  return leafGeometricError === null ? ownGeometricError : leafGeometricError;
 }
 
-function scaleTilesetGeometricErrors(tile, scale, pathLabel = 'tileset.root') {
+function scaleTilesetGeometricErrors(
+  tile,
+  geometricErrorScale,
+  geometricErrorLayerScale,
+  baseDir,
+  rootDir,
+  leafGeometricErrorCache,
+  pathLabel = 'tileset.root',
+) {
   if (!tile || typeof tile !== 'object') {
     return;
   }
@@ -195,7 +356,15 @@ function scaleTilesetGeometricErrors(tile, scale, pathLabel = 'tileset.root') {
   scaleGeometricErrorValue(
     tile,
     'geometricError',
-    scale,
+    geometricErrorScale,
+    geometricErrorLayerScale,
+    getTileLeafGeometricError(
+      tile,
+      baseDir,
+      rootDir,
+      leafGeometricErrorCache,
+      new Set(),
+    ),
     `${pathLabel}.geometricError`,
   );
 
@@ -206,7 +375,11 @@ function scaleTilesetGeometricErrors(tile, scale, pathLabel = 'tileset.root') {
   tile.children.forEach((child, index) => {
     scaleTilesetGeometricErrors(
       child,
-      scale,
+      geometricErrorScale,
+      geometricErrorLayerScale,
+      baseDir,
+      rootDir,
+      leafGeometricErrorCache,
       `${pathLabel}.children[${index}]`,
     );
   });
@@ -234,27 +407,8 @@ function collectExternalTilesetPaths(tile, baseDir, results) {
     return;
   }
 
-  const maybePaths = [];
-  if (tile.content && typeof tile.content === 'object') {
-    maybePaths.push(
-      getLocalJsonReferencePath(baseDir, tile.content.uri || tile.content.url),
-    );
-  }
-
-  if (Array.isArray(tile.contents)) {
-    tile.contents.forEach((entry) => {
-      if (entry && typeof entry === 'object') {
-        maybePaths.push(
-          getLocalJsonReferencePath(baseDir, entry.uri || entry.url),
-        );
-      }
-    });
-  }
-
-  maybePaths.forEach((filePath) => {
-    if (filePath) {
-      results.add(filePath);
-    }
+  getLocalExternalTilesetPaths(tile, baseDir).forEach((filePath) => {
+    results.add(filePath);
   });
 
   if (!Array.isArray(tile.children)) {
@@ -268,7 +422,13 @@ function collectExternalTilesetPaths(tile, baseDir, results) {
 
 function updateTilesetJsonFile(
   tilesetPath,
-  { geometricErrorScale, rootDir, rootTransform = null },
+  {
+    geometricErrorLayerScale,
+    geometricErrorScale,
+    rootDir,
+    rootTransform = null,
+    leafGeometricErrorCache = new Map(),
+  },
   visited = new Set(),
 ) {
   const resolvedPath = path.resolve(tilesetPath);
@@ -277,14 +437,7 @@ function updateTilesetJsonFile(
   }
   visited.add(resolvedPath);
 
-  if (
-    resolvedPath !== rootDir &&
-    !resolvedPath.startsWith(`${rootDir}${path.sep}`)
-  ) {
-    throw new InspectorError(
-      `Nested tileset path escapes the viewer root: ${resolvedPath}`,
-    );
-  }
+  assertTilesetPathInsideRoot(resolvedPath, rootDir);
 
   if (!fs.existsSync(resolvedPath)) {
     throw new InspectorError(
@@ -301,30 +454,41 @@ function updateTilesetJsonFile(
     tileset.root.transform = rootTransform.slice();
   }
 
+  const tilesetDir = path.dirname(resolvedPath);
   scaleGeometricErrorValue(
     tileset,
     'geometricError',
     geometricErrorScale,
+    geometricErrorLayerScale,
+    getTileLeafGeometricError(
+      tileset.root,
+      tilesetDir,
+      rootDir,
+      leafGeometricErrorCache,
+      new Set(),
+    ),
     `${resolvedPath}.geometricError`,
   );
   scaleTilesetGeometricErrors(
     tileset.root,
     geometricErrorScale,
+    geometricErrorLayerScale,
+    tilesetDir,
+    rootDir,
+    leafGeometricErrorCache,
     `${resolvedPath}.root`,
   );
   writeJsonAtomic(resolvedPath, tileset);
 
   const nestedTilesets = new Set();
-  collectExternalTilesetPaths(
-    tileset.root,
-    path.dirname(resolvedPath),
-    nestedTilesets,
-  );
+  collectExternalTilesetPaths(tileset.root, tilesetDir, nestedTilesets);
   nestedTilesets.forEach((childTilesetPath) => {
     updateTilesetJsonFile(
       childTilesetPath,
       {
+        geometricErrorLayerScale,
         geometricErrorScale,
+        leafGeometricErrorCache,
         rootDir,
       },
       visited,
@@ -337,13 +501,17 @@ function updateTilesetJsonFile(
 function saveViewerTransform(
   rootTilesetPath,
   editMatrix,
-  { geometricErrorScale = 1 } = {},
+  { geometricErrorLayerScale = 1, geometricErrorScale = 1 } = {},
 ) {
   const normalizedEdit = normalizeMatrix4Array(editMatrix, 'transform');
   const normalizedGeometricErrorScale = normalizePositiveFinite(
     geometricErrorScale,
     'geometricErrorScale',
   );
+  const normalizedGeometricErrorLayerScale = normalizePositiveFinite(
+    geometricErrorLayerScale,
+    'geometricErrorLayerScale',
+  );
   const tilesetPath = path.resolve(rootTilesetPath);
   const rootDir = path.dirname(tilesetPath);
 
@@ -366,6 +534,7 @@ function saveViewerTransform(
   const nextRoot = multiplyMatrix4(normalizedEdit, currentRoot);
 
   updateTilesetJsonFile(tilesetPath, {
+    geometricErrorLayerScale: normalizedGeometricErrorLayerScale,
     geometricErrorScale: normalizedGeometricErrorScale,
     rootDir,
     rootTransform: nextRoot,
@@ -386,6 +555,15 @@ function saveViewerTransform(
     summary.root_coordinate = null;
     summary.viewer_geometric_error_scale =
       previousGeometricErrorScale * normalizedGeometricErrorScale;
+    const previousGeometricErrorLayerScale =
+      summary.viewer_geometric_error_layer_scale == null
+        ? 1
+        : normalizePositiveFinite(
+            summary.viewer_geometric_error_layer_scale,
+            'build_summary.viewer_geometric_error_layer_scale',
+          );
+    summary.viewer_geometric_error_layer_scale =
+      previousGeometricErrorLayerScale * normalizedGeometricErrorLayerScale;
     writeJsonAtomic(summaryPath, summary);
   }
 
@@ -529,9 +707,28 @@ async function handleSaveTransformRequest(rootTilesetPath, req, res) {
     return;
   }
 
+  let normalizedGeometricErrorLayerScale;
+  try {
+    normalizedGeometricErrorLayerScale = normalizePositiveFinite(
+      payload.geometricErrorLayerScale == null
+        ? 1
+        : payload.geometricErrorLayerScale,
+      'geometricErrorLayerScale',
+    );
+  } catch (err) {
+    sendJson(res, 400, {
+      error:
+        err instanceof Error && err.message
+          ? err.message
+          : 'geometricErrorLayerScale must be a finite number greater than 0.',
+    });
+    return;
+  }
+
   let nextRoot;
   try {
     nextRoot = saveViewerTransform(rootTilesetPath, normalizedEdit, {
+      geometricErrorLayerScale: normalizedGeometricErrorLayerScale,
       geometricErrorScale: normalizedGeometricErrorScale,
     });
   } catch (err) {
@@ -547,6 +744,7 @@ async function handleSaveTransformRequest(rootTilesetPath, req, res) {
   sendJson(res, 200, {
     ok: true,
     transform: nextRoot,
+    geometricErrorLayerScale: normalizedGeometricErrorLayerScale,
     geometricErrorScale: normalizedGeometricErrorScale,
   });
 }
@@ -756,8 +954,8 @@ function buildViewerHtml(viewerConfig) {
       .toolbar {
         display: grid;
         align-content: start;
-        gap: 12px;
-        padding: 14px;
+        gap: 8px;
+        padding: 10px 14px;
         border: 1px solid rgba(22, 50, 79, 0.12);
         border-top: 0;
         border-radius: 0 0 20px 20px;
@@ -782,7 +980,7 @@ function buildViewerHtml(viewerConfig) {
         justify-content: center;
         width: 100%;
         min-height: 32px;
-        padding: 10px 12px;
+        padding: 8px 12px;
         border: 1px solid rgba(22, 50, 79, 0.08);
         border-radius: 20px 20px 0 0;
         font: inherit;
@@ -804,7 +1002,7 @@ function buildViewerHtml(viewerConfig) {
         justify-self: start;
         width: auto;
         min-height: 36px;
-        padding: 7px 12px 8px;
+        padding: 6px 12px 7px;
         border-radius: 999px;
         color: #506377;
         background: rgba(255, 255, 255, 0.94);
@@ -830,7 +1028,7 @@ function buildViewerHtml(viewerConfig) {
       .toolbar-section {
         display: grid;
         gap: 10px;
-        padding: 12px;
+        padding: 10px 12px;
         border: 1px solid rgba(22, 50, 79, 0.08);
         border-radius: 14px;
         background:
@@ -839,7 +1037,7 @@ function buildViewerHtml(viewerConfig) {
 
       .toolbar-section-header {
         display: flex;
-        align-items: center;
+        align-items: flex-start;
         justify-content: space-between;
         gap: 10px;
       }
@@ -857,7 +1055,7 @@ function buildViewerHtml(viewerConfig) {
         margin: 0;
         font-size: 12px;
         font-weight: 700;
-        color: #16324f;
+        color: #5d738b;
       }
 
       .button-row {
@@ -886,7 +1084,7 @@ function buildViewerHtml(viewerConfig) {
         justify-content: center;
         border: 0;
         border-radius: 999px;
-        padding: 9px 14px;
+        padding: 7px 14px;
         font: inherit;
         font-size: 14px;
         font-weight: 600;
@@ -922,6 +1120,14 @@ function buildViewerHtml(viewerConfig) {
 
       .range-field {
         display: grid;
+        gap: 4px;
+        min-width: 0;
+      }
+
+      .range-field-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
         gap: 8px;
         min-width: 0;
       }
@@ -1105,10 +1311,12 @@ function buildViewerHtml(viewerConfig) {
         <div class="toolbar-section">
           <div class="toolbar-section-header">
             <p class="toolbar-section-title">LOD</p>
-            <p id="geometric-error-value" class="toolbar-value">x1.00</p>
           </div>
           <label class="range-field">
-            <span>Geometric Error</span>
+            <div class="range-field-header">
+              <span>Geometric Error</span>
+              <p id="geometric-error-value" class="toolbar-value">x1.00</p>
+            </div>
             <input
               id="geometric-error-scale"
               type="range"
@@ -1118,6 +1326,20 @@ function buildViewerHtml(viewerConfig) {
               value="0"
             />
           </label>
+          <label class="range-field">
+            <div class="range-field-header">
+              <span>Layer Multiplier</span>
+              <p id="geometric-error-layer-value" class="toolbar-value">x1.00</p>
+            </div>
+            <input
+              id="geometric-error-layer-scale"
+              type="range"
+              min="-3"
+              max="3"
+              step="0.1"
+              value="0"
+            />
+          </label>
         </div>
         <div class="toolbar-section status-panel">
           <div class="status-actions">