@loaders.gl/tiles 4.4.5 → 5.0.0-alpha.2

package/src/{tileset → tileset-3d/common}/tile-3d.ts

@@ -8,23 +8,28 @@
 import {Vector3, Matrix4} from '@math.gl/core';
 import {CullingVolume} from '@math.gl/culling';
 
-import {load} from '@loaders.gl/core';
-
 // Note: circular dependency
 import type {Tileset3D} from './tileset-3d';
-import type {DoublyLinkedListNode} from '../utils/doubly-linked-list-node';
-import {TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE} from '../constants';
+import type {DoublyLinkedListNode} from '../../utils/doubly-linked-list-node';
+import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE} from '../../constants';
+import type {TileChildrenLoadResult, TileContentLoadResult} from './tileset-source';
 
-import {FrameState} from './helpers/frame-state';
+import {FrameState} from '../helpers/frame-state';
 import {
   createBoundingVolume,
   getCartographicBounds,
   CartographicBounds
-} from './helpers/bounding-volume';
-import {getTiles3DScreenSpaceError} from './helpers/tiles-3d-lod';
-import {getProjectedRadius} from './helpers/i3s-lod';
-import {get3dTilesOptions} from './helpers/3d-tiles-options';
+} from '../helpers/bounding-volume';
+import {getTiles3DScreenSpaceError} from '../helpers/tiles-3d-lod';
+import {getProjectedRadius} from '../helpers/i3s-lod';
 import {TilesetTraverser} from './tileset-traverser';
+import {
+  calculateFoveatedFactor,
+  calculateTileRequestPriority,
+  isFoveatedRequestDelayActive,
+  isFoveatedRequestDeferred,
+  isProgressiveResolutionPriority
+} from '../helpers/tiles-3d-request-priority';
 
 const scratchVector = new Vector3();
 
@@ -46,6 +51,9 @@ export type Tile3DProps = {
   extendedId: string;
 };
 
+/** Lifecycle of a source-managed lazy child-header group. */
+export type TileChildrenState = 'unloaded' | 'loading' | 'ready' | 'failed';
+
 /**
  * A Tile3DHeader represents a tile as Tileset3D. When a tile is first created, its content is not loaded;
  * the content is loaded on-demand when needed based on the view.
@@ -62,10 +70,19 @@ export class Tile3D {
   type: string;
   contentUrl: string;
   /** Different refinement algorithms used by I3S and 3D tiles */
-  lodMetricType: 'geometricError' | 'maxScreenThreshold' = 'geometricError';
-  /** The error, in meters, introduced if this tile is rendered and its children are not. */
+  lodMetricType = 'geometricError';
+  /**
+   * The world-space geometric error, in meters, introduced if this tile is rendered and its
+   * children are not. For I3S this stores the format's unscaled screen-threshold metric instead.
+   */
   lodMetricValue: number = 0;
 
+  /**
+   * The source LOD metric before applying the tile's computed transform. Keeping the source value
+   * separate ensures transform updates never compound an already-scaled geometric error.
+   */
+  private _unscaledLodMetricValue: number = 0;
+
   /** @todo math.gl is not exporting BoundingVolume base type? */
   boundingVolume: any = null;
 
@@ -79,6 +96,8 @@ export class Tile3D {
 
   /** The tile's children - an array of Tile3D objects. */
   children: Tile3D[] = [];
+  /** Current lifecycle state for a lazy implicit subtree rooted at this tile. */
+  childrenState: TileChildrenState = 'ready';
   depth: number = 0;
   viewportIds: any[] = [];
   transform = new Matrix4();
@@ -104,11 +123,22 @@ export class Tile3D {
   private _expireDate: any = null;
   private _expiredContent: any = null;
 
+  /** In-flight source request shared by repeated traversal frames. */
+  private _childrenPromise: Promise<TileChildrenLoadResult> | null = null;
+
   private _boundingBox?: CartographicBounds = undefined;
 
   /** updated every frame for tree traversal and rendering optimizations: */
   public _distanceToCamera: number = 0;
   _screenSpaceError: number = 0;
+  /** SSE calculated at the reduced viewport height used to prioritize coarse coverage. */
+  _screenSpaceErrorProgressiveResolution: number = 0;
+  /** Whether this tile should be promoted into the progressive-resolution request pass. */
+  _priorityProgressiveResolution: boolean = false;
+  /** Angular distance from the camera view axis used to prioritize center tiles. */
+  _foveatedFactor: number = 0;
+  /** Whether this peripheral request is currently inside the camera-motion deferral window. */
+  priorityDeferred: boolean = false;
   private _visibilityPlaneMask: any;
   private _visible: boolean | undefined = undefined;
 
@@ -169,9 +199,11 @@ export class Tile3D {
     this.refine = this._getRefine(header.refine);
     this.type = header.type;
     this.contentUrl = header.contentUrl;
+    this.childrenState = header.implicitSubtree ? 'unloaded' : 'ready';
 
     this._initializeLodMetric(header);
     this._initializeTransforms(header);
+    this._updateLodMetricScale();
     this._initializeBoundingVolumes(header);
     this._initializeContent(header);
     this._initializeRenderingState(header);
@@ -206,7 +238,24 @@ export class Tile3D {
 
   /** Returns true if tile has children */
   get hasChildren() {
-    return this.children.length > 0 || (this.header.children && this.header.children.length > 0);
+    return (
+      this.children.length > 0 ||
+      (this.header.children && this.header.children.length > 0) ||
+      Boolean(this.header.implicitSubtree && this.childrenState !== 'ready')
+    );
+  }
+
+  /** Returns whether traversal may request an unresolved lazy child-header group. */
+  get hasUnloadedChildren(): boolean {
+    return Boolean(
+      this.header.implicitSubtree &&
+        (this.childrenState === 'unloaded' || this.childrenState === 'failed')
+    );
+  }
+
+  /** Returns whether a lazy child-header request is currently in flight. */
+  get childrenLoading(): boolean {
+    return this.childrenState === 'loading';
   }
 
   /**
@@ -279,13 +328,28 @@ export class Tile3D {
     return this._boundingBox;
   }
 
-  /** Get the tile's screen space error. */
-  getScreenSpaceError(frameState, useParentLodMetric) {
+  /**
+   * Gets the tile's screen-space error for normal refinement or a reduced-height priority pass.
+   *
+   * I3S already supplies a screen-oriented LOD metric and intentionally ignores the optional 3D
+   * Tiles progressive-resolution height fraction.
+   *
+   * @param frameState - Current camera and viewport measurements.
+   * @param useParentLodMetric - Whether to substitute the parent LOD metric.
+   * @param viewportHeightFraction - Fraction of viewport height represented by the priority pass.
+   * @returns Screen-space LOD error for the current tileset format.
+   */
+  getScreenSpaceError(frameState, useParentLodMetric, viewportHeightFraction = 1) {
     switch (this.tileset.type) {
       case TILESET_TYPE.I3S:
         return getProjectedRadius(this, frameState);
       case TILESET_TYPE.TILES3D:
-        return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);
+        return getTiles3DScreenSpaceError(
+          this,
+          frameState,
+          useParentLodMetric,
+          viewportHeightFraction
+        );
       default:
         // eslint-disable-next-line
         throw new Error('Unsupported tileset type');
@@ -307,12 +371,36 @@ export class Tile3D {
     return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
   }
 
-  /*
-   * If skipLevelOfDetail is off try to load child tiles as soon as possible so that their parent can refine sooner.
-   * Tiles are prioritized by screen space error.
+  /**
+   * Returns scheduler priority for render-content requests.
+   *
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
+   */
+  _getPriority(): number {
+    return this._calculateRequestPriority(false);
+  }
+
+  /**
+   * Returns scheduler priority for lazy child-header requests.
+   *
+   * Contentless implicit placeholders intentionally retain `UNLOADED` content state, so metadata
+   * scheduling skips only that render-content cancellation check and preserves every visibility,
+   * recency, progressive, foveated, and motion-deferral rule.
+   *
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
+   */
+  private _getChildrenPriority(): number {
+    return this._calculateRequestPriority(true);
+  }
+
+  /**
+   * Calculates the common scheduler priority for content or hierarchy metadata.
+   *
+   * @param allowUnloadedContent - Whether an empty placeholder may request child metadata.
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
    */
   // eslint-disable-next-line complexity
-  _getPriority() {
+  private _calculateRequestPriority(allowUnloadedContent: boolean): number {
     const traverser = this.tileset._traverser;
     const {skipLevelOfDetail} = traverser.options;
 
@@ -332,7 +420,13 @@ export class Tile3D {
     if (this.tileset._frameNumber - this._touchedFrame >= 1) {
       return -1;
     }
-    if (this.contentState === TILE_CONTENT_STATE.UNLOADED) {
+    // RequestScheduler re-evaluates this callback before a queued request receives a slot. A
+    // negative priority cancels work that became deferred after it was queued; the scheduled
+    // follow-up traversal submits it again after the motion delay expires.
+    if (this.priorityDeferred) {
+      return -1;
+    }
+    if (!allowUnloadedContent && this.contentState === TILE_CONTENT_STATE.UNLOADED) {
       return -1;
     }
 
@@ -346,8 +440,15 @@ export class Tile3D {
 
     const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;
 
-    // Map higher SSE to lower values (e.g. root tile is highest priority)
-    return Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    // Map higher SSE to lower values (e.g. root tile is highest priority), then combine the
+    // existing order with independent progressive and foveated priority bands.
+    const reverseScreenSpaceError = Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    return calculateTileRequestPriority({
+      priorityProgressiveResolution: this._priorityProgressiveResolution,
+      foveatedFactor: this._foveatedFactor,
+      reverseScreenSpaceError,
+      rootScreenSpaceError
+    });
   }
 
   /**
@@ -355,13 +456,13 @@ export class Tile3D {
    * The request may not be made if the Request Scheduler can't prioritize it.
    */
   // eslint-disable-next-line max-statements, complexity
-  async loadContent(): Promise<boolean> {
+  async loadContent(): Promise<TileContentLoadResult> {
     if (this.hasEmptyContent) {
-      return false;
+      return {loaded: false};
     }
 
     if (this.content) {
-      return true;
+      return {loaded: true};
     }
 
     const expired = this.contentExpired;
@@ -380,40 +481,19 @@ export class Tile3D {
     if (!requestToken) {
       // cancelled
       this.contentState = TILE_CONTENT_STATE.UNLOADED;
-      return false;
+      return {loaded: false};
     }
 
     try {
-      const contentUrl = this.tileset.getTileUrl(this.contentUrl);
-      // The content can be a binary tile ot a JSON tileset
-      const loader = this.tileset.loader;
-      const tilesetLoaderOptions =
-        (this.tileset.loadOptions[loader.id] as Record<string, unknown>) || {};
-      const options = {
-        ...this.tileset.loadOptions,
-        [loader.id]: {
-          ...tilesetLoaderOptions,
-          isTileset: this.type === 'json',
-          ...this._getLoaderSpecificOptions(loader.id)
-        } // TODO add typecheck - as const satisfies ...
-      };
-
-      this.content = await load(contentUrl, loader, options);
+      const loadResult = await this.tileset.source.loadTileContent(this);
 
       if (this.tileset.options.contentLoader) {
         await this.tileset.options.contentLoader(this);
       }
 
-      if (this._isTileset()) {
-        // Add tile headers for the nested tilset's subtree
-        // Async update of the tree should be fine since there would never be edits to the same node
-        // TODO - we need to capture the child tileset's URL
-        this.tileset._initializeTileHeaders(this.content, this);
-      }
-
       this.contentState = TILE_CONTENT_STATE.READY;
       this._onContentLoaded();
-      return true;
+      return loadResult;
     } catch (error) {
       // Tile is unloaded before the content finishes loading
       this.contentState = TILE_CONTENT_STATE.FAILED;
@@ -423,6 +503,96 @@ export class Tile3D {
     }
   }
 
+  /**
+   * Requests and installs this tile's lazy child-header group through its source.
+   *
+   * The same request scheduler and SSE/foveated priority value used for render content are reused
+   * for subtree metadata. Repeated traversal frames share one promise, and scheduler cancellation
+   * restores the unloaded state so a later frame can retry.
+   *
+   * @param frameState - View state that made the subtree eligible for refinement.
+   * @returns Source load result, or an unloaded result if scheduling was cancelled.
+   */
+  async loadChildren(frameState: FrameState): Promise<TileChildrenLoadResult> {
+    if (!this.header.implicitSubtree || this.childrenState === 'ready') {
+      return {loaded: false, tileCount: 0, childSubtreeCount: 0};
+    }
+    if (this._childrenPromise) {
+      return await this._childrenPromise;
+    }
+    if (!this.tileset.source.loadTileChildren) {
+      throw new Error('Tileset source does not support lazy tile children');
+    }
+
+    this.childrenState = 'loading';
+    this._childrenPromise = this._loadChildrenWithScheduler(frameState);
+    try {
+      return await this._childrenPromise;
+    } finally {
+      this._childrenPromise = null;
+    }
+  }
+
+  /**
+   * Runs one lazy child-header load after obtaining a scheduler token.
+   *
+   * @param frameState - View state forwarded to the source implementation.
+   * @returns Source load result.
+   */
+  private async _loadChildrenWithScheduler(
+    frameState: FrameState
+  ): Promise<TileChildrenLoadResult> {
+    const requestToken = await this.tileset._requestScheduler.scheduleRequest(
+      `${this.id}:implicit-subtree`,
+      this._getChildrenPriority.bind(this)
+    );
+    if (!requestToken) {
+      this.childrenState = 'unloaded';
+      return {loaded: false, tileCount: 0, childSubtreeCount: 0};
+    }
+
+    try {
+      const loadResult = await this.tileset.source.loadTileChildren!(this, frameState);
+      this.childrenState = loadResult.loaded ? 'ready' : 'unloaded';
+      return loadResult;
+    } catch (error) {
+      this.childrenState = 'failed';
+      throw error;
+    } finally {
+      requestToken.done();
+    }
+  }
+
+  /**
+   * Replaces a contentless implicit placeholder with its materialized subtree-root header.
+   *
+   * Transform state is intentionally preserved: the placeholder already owns the composed
+   * transform, and reapplying the root transform here would double-transform bounds and geometric
+   * error. Content and raw geometric error are reinitialized from the newly available header.
+   *
+   * @param materializedHeader - Available root header produced from one subtree resource.
+   */
+  applyImplicitSubtreeHeader(materializedHeader: Record<string, any>): void {
+    const existingTransform = this.header.transform;
+    const existingTransformMatrix = this.header.transformMatrix;
+    this.header = {
+      ...this.header,
+      ...materializedHeader,
+      transform: existingTransform,
+      transformMatrix: existingTransformMatrix,
+      implicitSubtree: undefined
+    };
+    this.refine = this._getRefine(materializedHeader.refine);
+    this.type = materializedHeader.type;
+    this.contentUrl = materializedHeader.contentUrl;
+    this._initializeLodMetric(materializedHeader);
+    this._updateLodMetricScale();
+    this._initializeBoundingVolumes(this.header);
+    // Use the merged header so inherited viewer-request-volume metadata remains available when a
+    // materialized implicit tile has no render content of its own.
+    this._initializeContent(this.header);
+  }
+
   // Unloads the tile's content.
   unloadContent() {
     if (this.content && this.content.destroy) {
@@ -463,6 +633,7 @@ export class Tile3D {
 
     this._distanceToCamera = this.distanceToTile(frameState);
     this._screenSpaceError = this.getScreenSpaceError(frameState, false);
+    this._updateRequestPriorityMetrics(frameState);
     this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask); // Use parent's plane mask to speed up visibility test
     this._visible = this._visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;
     this._inRequestVolume = this.insideViewerRequestVolume(frameState);
@@ -471,6 +642,71 @@ export class Tile3D {
     this.viewportIds = viewportIds;
   }
 
+  /**
+   * Updates progressive-resolution and foveated request metrics for a 3D Tiles traversal frame.
+   *
+   * I3S retains its format-specific screen-threshold ordering and is explicitly isolated from
+   * geometric-error scheduling. Orthographic viewports still receive progressive coverage, but
+   * angular foveation is disabled because an orthographic frustum has no perspective field of view.
+   *
+   * @param frameState - Current camera and viewport measurements.
+   */
+  _updateRequestPriorityMetrics(frameState: FrameState): void {
+    if (this.tileset.type !== TILESET_TYPE.TILES3D) {
+      this._screenSpaceErrorProgressiveResolution = this._screenSpaceError;
+      this._priorityProgressiveResolution = false;
+      this._foveatedFactor = 0;
+      this.priorityDeferred = false;
+      return;
+    }
+
+    const options = this.tileset.options;
+    const progressiveResolutionHeightFraction = options.progressiveResolutionHeightFraction;
+    this._screenSpaceErrorProgressiveResolution = this.getScreenSpaceError(
+      frameState,
+      false,
+      progressiveResolutionHeightFraction
+    );
+    this._priorityProgressiveResolution = isProgressiveResolutionPriority(
+      this._screenSpaceErrorProgressiveResolution,
+      this.parent?._screenSpaceErrorProgressiveResolution,
+      this.tileset.memoryAdjustedScreenSpaceError,
+      progressiveResolutionHeightFraction
+    );
+
+    if (
+      !options.foveatedScreenSpaceError ||
+      frameState.viewport?.orthographic ||
+      !frameState.camera?.position ||
+      !frameState.camera?.direction
+    ) {
+      this._foveatedFactor = 0;
+      this.priorityDeferred = false;
+      return;
+    }
+
+    this._foveatedFactor = calculateFoveatedFactor(this.boundingVolume, frameState.camera);
+    const deferralEligible = isFoveatedRequestDeferred({
+      refinement: this.refine,
+      skipLevelOfDetail: this.tileset._traverser.options.skipLevelOfDetail,
+      foveatedScreenSpaceError: options.foveatedScreenSpaceError,
+      foveatedConeSize: options.foveatedConeSize,
+      minimumScreenSpaceErrorRelaxation: options.foveatedMinimumScreenSpaceErrorRelaxation,
+      interpolationCallback: options.foveatedInterpolationCallback,
+      foveatedFactor: this._foveatedFactor,
+      verticalFieldOfView: frameState.camera.verticalFieldOfView,
+      screenSpaceError: this._screenSpaceError,
+      parentScreenSpaceError: this.parent?._screenSpaceError,
+      maximumScreenSpaceError: this.tileset.memoryAdjustedScreenSpaceError,
+      priorityProgressiveResolution: this._priorityProgressiveResolution
+    });
+    this.priorityDeferred = isFoveatedRequestDelayActive(
+      deferralEligible,
+      frameState.camera.timeSinceMovement,
+      options.foveatedTimeDelay
+    );
+  }
+
   // Determines whether the tile's bounding volume intersects the culling volume.
   // @param {FrameState} frameState The frame state.
   // @param {Number} parentVisibilityPlaneMask The parent's plane mask to speed up the visibility check.
@@ -592,7 +828,8 @@ export class Tile3D {
 
   // INTERNAL METHODS
 
-  _initializeLodMetric(header) {
+  /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
+  _initializeLodMetric(header: {[key: string]: any}): void {
     if ('lodMetricType' in header) {
       this.lodMetricType = header.lodMetricType;
     } else {
@@ -603,15 +840,20 @@ export class Tile3D {
 
     // This is used to compute screen space error, i.e., the error measured in pixels.
     if ('lodMetricValue' in header) {
-      this.lodMetricValue = header.lodMetricValue;
+      this._unscaledLodMetricValue = header.lodMetricValue;
     } else {
-      this.lodMetricValue =
-        (this.parent && this.parent.lodMetricValue) || this.tileset.lodMetricValue;
+      // Inherit the source value, not the parent's world-space value. The child's complete
+      // transform will be applied after transform initialization below.
+      this._unscaledLodMetricValue = this.parent
+        ? this.parent._unscaledLodMetricValue
+        : this.tileset.lodMetricValue;
       // eslint-disable-next-line
       console.warn(
         '3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue'
       );
     }
+
+    this.lodMetricValue = this._unscaledLodMetricValue;
   }
 
   _initializeTransforms(tileHeader) {
@@ -632,6 +874,28 @@ export class Tile3D {
     this._initialTransform = new Matrix4(parentInitialTransform).multiplyRight(this.transform);
   }
 
+  /**
+   * Updates the world-space LOD metric from the source metric and the complete tile transform.
+   *
+   * 3D Tiles geometric error is a distance in the tile's local meters. Screen-space error (SSE)
+   * compares that distance with a world-space camera distance, so both quantities must use the
+   * same scale. For non-uniform transforms the largest axis scale is deliberately used: this is
+   * conservative and prevents refinement from stopping while any transformed dimension can still
+   * exceed the requested visual error. Rotation and translation do not affect the scale.
+   *
+   * I3S `maxScreenThreshold` is already a screen-space metric and must not be transform-scaled.
+   */
+  _updateLodMetricScale(): void {
+    if (this.lodMetricType !== LOD_METRIC_TYPE.GEOMETRIC_ERROR) {
+      this.lodMetricValue = this._unscaledLodMetricValue;
+      return;
+    }
+
+    const transformScale = this.computedTransform.getScale(scratchVector);
+    const maximumScale = Math.max(transformScale[0], transformScale[1], transformScale[2]);
+    this.lodMetricValue = this._unscaledLodMetricValue * maximumScale;
+  }
+
   _initializeBoundingVolumes(tileHeader) {
     this._contentBoundingVolume = null;
     this._viewerRequestVolume = null;
@@ -664,6 +928,10 @@ export class Tile3D {
     this._distanceToCamera = 0;
     this._centerZDepth = 0;
     this._screenSpaceError = 0;
+    this._screenSpaceErrorProgressiveResolution = 0;
+    this._priorityProgressiveResolution = false;
+    this._foveatedFactor = 0;
+    this.priorityDeferred = false;
     this._visibilityPlaneMask = CullingVolume.MASK_INDETERMINATE;
     this._visible = undefined;
     this._inRequestVolume = false;
@@ -685,8 +953,15 @@ export class Tile3D {
     return refine || (this.parent && this.parent.refine) || TILE_REFINEMENT.REPLACE;
   }
 
-  _isTileset() {
-    return this.contentUrl.indexOf('.json') !== -1;
+  /**
+   * Returns whether loaded content is an external tileset.
+   *
+   * Parsed shape is authoritative because valid external resources may be extensionless, signed,
+   * or use a misleading filename. This method is called only after source loading has populated
+   * `content`.
+   */
+  _isTileset(): boolean {
+    return this.content?.shape === 'tileset3d';
   }
 
   _onContentLoaded() {
@@ -716,6 +991,17 @@ export class Tile3D {
       this.boundingVolume
     );
 
+    // Viewer request volumes constrain traversal, not just render content. A contentless implicit
+    // connector can still own an inherited request volume, so initialize it before the
+    // content-specific early return below.
+    if (header.viewerRequestVolume) {
+      this._viewerRequestVolume = createBoundingVolume(
+        header.viewerRequestVolume,
+        this.computedTransform,
+        this._viewerRequestVolume
+      );
+    }
+
     const content = header.content;
     if (!content) {
       return;
@@ -734,17 +1020,13 @@ export class Tile3D {
         this._contentBoundingVolume
       );
     }
-    if (header.viewerRequestVolume) {
-      this._viewerRequestVolume = createBoundingVolume(
-        header.viewerRequestVolume,
-        this.computedTransform,
-        this._viewerRequestVolume
-      );
-    }
   }
 
-  // Update the tile's transform. The transform is applied to the tile's bounding volumes.
-  _updateTransform(parentTransform = new Matrix4()) {
+  /**
+   * Updates the tile's computed transform, world-space geometric error, and bounding volumes.
+   * @param parentTransform - Current computed transform of the parent tile or tileset.
+   */
+  _updateTransform(parentTransform = new Matrix4()): void {
     const computedTransform = parentTransform.clone().multiplyRight(this.transform);
     const didTransformChange = !computedTransform.equals(this.computedTransform);
 
@@ -754,35 +1036,8 @@ export class Tile3D {
 
     this.computedTransform = computedTransform;
 
+    // Recalculate from the unscaled source metric so repeated model-matrix changes never compound.
+    this._updateLodMetricScale();
     this._updateBoundingVolume(this.header);
   }
-
-  // Get options which are applicable only for the particular loader
-  _getLoaderSpecificOptions(loaderId) {
-    switch (loaderId) {
-      case 'i3s':
-        return {
-          ...this.tileset.options.i3s,
-          _tileOptions: {
-            attributeUrls: this.header.attributeUrls,
-            textureUrl: this.header.textureUrl,
-            textureFormat: this.header.textureFormat,
-            textureLoaderOptions: this.header.textureLoaderOptions,
-            materialDefinition: this.header.materialDefinition,
-            isDracoGeometry: this.header.isDracoGeometry,
-            mbs: this.header.mbs
-          },
-          _tilesetOptions: {
-            store: this.tileset.tileset.store,
-            attributeStorageInfo: this.tileset.tileset.attributeStorageInfo,
-            fields: this.tileset.tileset.fields
-          },
-          isTileHeader: false
-        };
-      case '3d-tiles':
-      case 'cesium-ion':
-      default:
-        return get3dTilesOptions(this.tileset.tileset);
-    }
-  }
 }