@loaders.gl/tiles 5.0.0-alpha.1 → 5.0.0-alpha.3

package/src/tileset-3d/format-i3s/i3s-source.ts

@@ -25,6 +25,8 @@ import type {
 import {getZoomFromExtent, getZoomFromFullExtent} from '../helpers/zoom';
 import {TILESET_TYPE} from '../../constants';
 import type {TilesetTraverser, TilesetTraverserProps} from '../common/tileset-traverser';
+import {getI3SSpatialReference} from '../../spatial/format-spatial-reference';
+import {I3SSpatialTransformer} from '../../spatial/i3s-spatial-transformer';
 
 const EMPTY_CONTENT_FORMATS: TilesetContentFormats = {
   draco: false,
@@ -63,6 +65,10 @@ export class I3SSource implements Tileset3DSource {
   private readonly queryParams: Record<string, string> = {};
   private readonly resolver?: TilesetSourceResolver;
   private rootTileset: TilesetJSON;
+  /** Spatial adapter created lazily after Tileset3D applies target options. */
+  private spatialTransformer?: I3SSpatialTransformer;
+  /** Root header prepared after asynchronous elevation sampling. */
+  private preparedRootHeader?: any;
 
   /**
    * Creates an I3S source.
@@ -79,6 +85,7 @@ export class I3SSource implements Tileset3DSource {
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
+    this.initializeQueryParams(loadOptions);
   }
 
   /**
@@ -86,7 +93,7 @@ export class I3SSource implements Tileset3DSource {
    */
   async initialize(): Promise<void> {
     if (!this.rootTileset) {
-      this.rootTileset = await this.loadRootData(this.url, this.loadOptions);
+      this.rootTileset = await this.loadRootData(this.getTileUrl(this.url), this.loadOptions);
     }
     this.tileset = this.rootTileset;
 
@@ -94,14 +101,6 @@ export class I3SSource implements Tileset3DSource {
       this.rootTileset.root = await this.rootTileset.root;
     }
 
-    const i3sOptions = this.loadOptions.i3s;
-    if (i3sOptions && typeof i3sOptions === 'object' && 'token' in i3sOptions) {
-      const token = (i3sOptions as Record<string, unknown>).token;
-      if (typeof token === 'string') {
-        this.queryParams.token = token;
-      }
-    }
-
     this.metadata = {
       type: this.type,
       loader: this.loader,
@@ -110,7 +109,8 @@ export class I3SSource implements Tileset3DSource {
       tileset: this.rootTileset,
       lodMetricType: this.rootTileset.lodMetricType,
       lodMetricValue: this.rootTileset.lodMetricValue,
-      refine: this.rootTileset.root?.refine
+      refine: this.rootTileset.root?.refine,
+      spatialReference: getI3SSpatialReference(this.rootTileset)
     };
   }
 
@@ -131,6 +131,26 @@ export class I3SSource implements Tileset3DSource {
     return this.getMetadata().tileset;
   }
 
+  /** Prepare option-dependent spatial state and the asynchronously placed root bound. */
+  async prepareTileset(tileset: Tileset3D): Promise<void> {
+    const spatialReference = tileset.spatialReference;
+    if (spatialReference.status === 'unresolved') {
+      throw new Error(
+        spatialReference.warnings[0] ||
+          'I3S spatial operations cannot be resolved from the supplied metadata and options'
+      );
+    }
+    if (spatialReference.status !== 'transformable' && spatialReference.status !== 'transformed') {
+      return;
+    }
+    this.spatialTransformer ||= new I3SSpatialTransformer(
+      spatialReference,
+      tileset.options.spatial
+    );
+    tileset.spatialReference = this.spatialTransformer.spatialReference;
+    this.preparedRootHeader = await this.transformTileHeader(this.getMetadata().tileset.root);
+  }
+
   /**
    * Creates the runtime root tile for an I3S subtree.
    */
@@ -139,7 +159,11 @@ export class I3SSource implements Tileset3DSource {
     tilesetJson: TilesetJSON,
     parentTile?: Tile3D | null
   ): Tile3D {
-    const rootTile = new Tile3DNode(tileset, tilesetJson.root, parentTile || undefined);
+    const rootHeader = parentTile ? tilesetJson.root : this.preparedRootHeader || tilesetJson.root;
+    if (this.spatialTransformer && !this.preparedRootHeader) {
+      throw new Error('I3S spatial root header was not prepared before tile initialization');
+    }
+    const rootTile = new Tile3DNode(tileset, rootHeader, parentTile || undefined);
     if (parentTile) {
       parentTile.children.push(rootTile);
       rootTile.depth = parentTile.depth + 1;
@@ -170,16 +194,22 @@ export class I3SSource implements Tileset3DSource {
         _tileOptions: {
           attributeUrls: tile.header.attributeUrls,
           textureUrl: tile.header.textureUrl,
+          textureUrls: tile.header.textureUrls,
           textureFormat: tile.header.textureFormat,
           textureLoaderOptions: tile.header.textureLoaderOptions,
           materialDefinition: tile.header.materialDefinition,
+          layerType: tile.header.layerType,
+          pointRenderer: tile.header.pointRenderer,
+          pointSymbol: tile.header.pointSymbol,
           isDracoGeometry: tile.header.isDracoGeometry,
           mbs: tile.header.mbs
         },
         _tilesetOptions: {
           store: metadata.tileset.store,
           attributeStorageInfo: metadata.tileset.attributeStorageInfo,
-          fields: metadata.tileset.fields
+          fields: metadata.tileset.fields,
+          spatialReference: tile.tileset.spatialReference,
+          spatialOptions: tile.tileset.options.spatial
         },
         isTileHeader: false
       }
@@ -198,8 +228,9 @@ export class I3SSource implements Tileset3DSource {
     _frameState: FrameState
   ): Promise<any> {
     const metadata = this.getMetadata();
-    if (metadata.tileset.nodePages) {
-      return await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+    if (metadata.tileset.nodePages || metadata.tileset.pointNodePages) {
+      const header = await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+      return await this.transformTileHeader(header);
     }
 
     const nodeUrl = this.getTileUrl(`${this.url}/nodes/${childId}`);
@@ -215,7 +246,8 @@ export class I3SSource implements Tileset3DSource {
       }
     };
 
-    return await this.loadResourceData(nodeUrl, options);
+    const header = await this.loadResourceData(nodeUrl, options);
+    return await this.transformTileHeader(header);
   }
 
   /**
@@ -230,14 +262,48 @@ export class I3SSource implements Tileset3DSource {
       return tilePath;
     }
 
-    const queryParams = new URLSearchParams(this.queryParams).toString();
-    return `${tilePath}${tilePath.includes('?') ? '&' : '?'}${queryParams}`;
+    const queryDelimiterIndex = tilePath.indexOf('?');
+    if (queryDelimiterIndex === -1) {
+      return `${tilePath}?${new URLSearchParams(this.queryParams).toString()}`;
+    }
+
+    const existingQuery = tilePath.slice(queryDelimiterIndex + 1);
+    const existingQueryKeys = new Set(
+      existingQuery.split('&').map(parameter => parameter.split('=', 1)[0])
+    );
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(this.queryParams)) {
+      if (!existingQueryKeys.has(key)) {
+        queryParams.set(key, value);
+      }
+    }
+
+    const queryString = queryParams.toString();
+    return queryString ? `${tilePath}${existingQuery ? '&' : ''}${queryString}` : tilePath;
   }
 
   /**
    * Derives the default view state from full extent or store extent metadata.
    */
-  getViewState(_rootTile: Tile3D | null): TilesetSourceViewState {
+  getViewState(rootTile: Tile3D | null): TilesetSourceViewState {
+    if (this.spatialTransformer && rootTile) {
+      const center = new Vector3(rootTile.boundingVolume.center);
+      const cartographicCenter = new Vector3(rootTile.header.i3sLodMbs.slice(0, 3));
+      if (this.spatialTransformer.targetCoordinateFrame === 'geographic') {
+        return {
+          boundingVolume: rootTile.boundingVolume,
+          cartographicCenter,
+          cartesianCenter: center,
+          zoom: 1
+        };
+      }
+      return {
+        boundingVolume: rootTile.boundingVolume,
+        cartographicCenter,
+        cartesianCenter: center,
+        zoom: 1
+      };
+    }
     const metadata = this.getMetadata();
     const fullExtent = metadata.tileset.fullExtent;
     if (fullExtent) {
@@ -325,6 +391,20 @@ export class I3SSource implements Tileset3DSource {
     return await this.loadWithCoreApi(url, options);
   }
 
+  /**
+   * Initializes query parameters before any URL-backed resource is requested.
+   * @param loadOptions Loader options that may contain an ArcGIS token.
+   */
+  private initializeQueryParams(loadOptions: LoaderOptions): void {
+    const i3sOptions = loadOptions.i3s;
+    if (i3sOptions && typeof i3sOptions === 'object' && 'token' in i3sOptions) {
+      const token = (i3sOptions as Record<string, unknown>).token;
+      if (typeof token === 'string') {
+        this.queryParams.token = token;
+      }
+    }
+  }
+
   /**
    * Loads tile metadata or content through an injected resolver when present, otherwise through the injected core API.
    */
@@ -335,6 +415,27 @@ export class I3SSource implements Tileset3DSource {
 
     return await this.loadWithCoreApi(url, options);
   }
+
+  /** Transform one I3S header bound after target options and elevation providers are available. */
+  private async transformTileHeader(header: any): Promise<any> {
+    if (!this.spatialTransformer) {
+      return header;
+    }
+    const sourceBounds = {
+      mbs: header.mbs,
+      obb: header.obb,
+      normalReferenceFrame: this.getMetadata().tileset.store?.normalReferenceFrame
+    };
+    const transformedBounds = await this.spatialTransformer.transformBoundsAsync(sourceBounds);
+    return {
+      ...header,
+      // Tileset3D traversal and culling operate in WGS84 ECEF independently of content output.
+      boundingVolume: transformedBounds.boundingVolume,
+      // Preserve the renderer/output-frame bound for applications and content coordination.
+      spatialBoundingVolume: transformedBounds.spatialBoundingVolume,
+      i3sLodMbs: transformedBounds.i3sLodMbs
+    };
+  }
 }
 
 function isTilesetRequest(input: TilesetSourceInput): input is TilesetSourceRequest {

package/src/tileset-3d/format-i3s/i3s-tile-manager.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {FrameState} from '../helpers/frame-state';
 import {I3SPendingTilesRegister} from './i3s-pending-tiles-register';
 

package/src/tileset-3d/format-i3s/i3s-tileset-traverser.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {TilesetTraverser} from '../common/tileset-traverser';
 
 import {getLodStatus} from '../helpers/i3s-lod';

package/src/tileset-3d/helpers/3d-tiles-options.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {Tileset3D} from '../common/tileset-3d';
 
 export function get3dTilesOptions(tileset: Tileset3D): {assetGltfUpAxis: 'X' | 'Y' | 'Z'} {

package/src/tileset-3d/helpers/bounding-volume.ts

@@ -1,10 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+
 // This file is derived from the Cesium code base under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
-import {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';
+import {Quaternion, Vector3, Matrix3, degrees} from '@math.gl/core';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
-import {Ellipsoid} from '@math.gl/geospatial';
+import {Ellipsoid, makeOBBFromRegion} from '@math.gl/geospatial';
 import {assert} from '@loaders.gl/loader-utils';
 
 // const scratchProjectedBoundingSphere = new BoundingSphere();
@@ -16,12 +18,6 @@ function defined(x) {
 // const scratchMatrix = new Matrix3();
 const scratchPoint = new Vector3();
 const scratchScale = new Vector3();
-const scratchNorthWest = new Vector3();
-const scratchSouthEast = new Vector3();
-const scratchCenter = new Vector3();
-const scratchXAxis = new Vector3();
-const scratchYAxis = new Vector3();
-const scratchZAxis = new Vector3();
 // const scratchRectangle = new Rectangle();
 // const scratchOrientedBoundingBox = new OrientedBoundingBox();
 // const scratchTransform = new Matrix4();
@@ -42,7 +38,7 @@ export function createBoundingVolume(boundingVolumeHeader, transform, result?) {
     return createBox(boundingVolumeHeader.box, transform, result);
   }
   if (boundingVolumeHeader.region) {
-    return createObbFromRegion(boundingVolumeHeader.region);
+    return makeOBBFromRegion(boundingVolumeHeader.region);
   }
 
   if (boundingVolumeHeader.sphere) {
@@ -219,52 +215,6 @@ function createSphere(sphere, transform, result?) {
   return new BoundingSphere(center, radius);
 }
 
-/**
- * Create OrientedBoundingBox instance from region 3D tiles bounding volume
- * @param region - region 3D tiles bounding volume
- * @returns OrientedBoundingBox instance
- */
-function createObbFromRegion(region: number[]): OrientedBoundingBox {
-  // [west, south, east, north, minimum height, maximum height]
-  // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.
-  // Heights are in meters above (or below) the WGS 84 ellipsoid.
-  const [west, south, east, north, minHeight, maxHeight] = region;
-
-  const northWest = Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(west), degrees(north), minHeight],
-    scratchNorthWest
-  );
-  const southEast = Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(east), degrees(south), maxHeight],
-    scratchSouthEast
-  );
-  const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
-  Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
-
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(east), scratchCenter[1], scratchCenter[2]],
-    scratchXAxis
-  );
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], degrees(north), scratchCenter[2]],
-    scratchYAxis
-  );
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], scratchCenter[1], maxHeight],
-    scratchZAxis
-  );
-
-  return createBox(
-    [
-      ...centerInCartesian,
-      ...scratchXAxis.subtract(centerInCartesian),
-      ...scratchYAxis.subtract(centerInCartesian),
-      ...scratchZAxis.subtract(centerInCartesian)
-    ],
-    new Matrix4()
-  );
-}
-
 /**
  * Convert a bounding volume defined by OrientedBoundingBox to cartographic bounds
  * @returns {CartographicBounds}

package/src/tileset-3d/helpers/frame-state.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {Tile3D} from '../common/tile-3d';
 import {Vector3} from '@math.gl/core';
 import {CullingVolume, Plane} from '@math.gl/culling';
@@ -6,20 +10,59 @@ import {GeospatialViewport, Viewport} from '../../types';
 
 export type FrameState = {
   camera: {
+    /** Camera position in WGS84 Cartesian meters. */
     position: number[];
+    /** Normalized camera direction in WGS84 Cartesian coordinates. */
     direction: number[];
+    /** Normalized camera up direction in WGS84 Cartesian coordinates. */
     up: number[];
+    /** Camera position as `[longitude, latitude, height]`, with height in meters. */
+    cartographicPosition: [number, number, number];
+    /** Perspective vertical field of view in radians. */
+    verticalFieldOfView: number;
+    /** Elapsed seconds since camera position or direction last changed. */
+    timeSinceMovement: number;
   };
   viewport: GeospatialViewport;
   topDownViewport: GeospatialViewport; // Use it to calculate projected radius for a tile
   height: number;
   cullingVolume: CullingVolume;
+  /** Optional world-space clipping planes applied to render-content culling. */
+  clippingPlanes?: Plane[];
   frameNumber: number; // TODO: This can be the same between updates, what number is unique for between updates?
   sseDenominator: number; // Assumes fovy = 60 degrees
+  /** View-dependent density used by perspective dynamic screen-space error for this traversal. */
+  dynamicScreenSpaceErrorDensity: number;
+};
+
+/** Optional camera and projection measurements supplied when constructing a frame state. */
+export type GetFrameStateOptions = {
+  /** Elapsed seconds since camera position or direction last changed. */
+  timeSinceCameraMovement?: number;
+};
+
+/** Camera pose and timestamp retained between traversal frames. */
+export type CameraMotionState = {
+  /** Last observed Earth-centered, Earth-fixed camera position. */
+  position: number[];
+  /** Last observed normalized Earth-centered, Earth-fixed camera direction. */
+  direction: number[];
+  /** Timestamp in milliseconds of the last observed pose change. */
+  lastMovementTime: number;
+};
+
+/** Updated camera state and elapsed stationary time for a traversal frame. */
+export type CameraMotionUpdate = {
+  /** Camera pose to retain for the next traversal. */
+  state: CameraMotionState;
+  /** Elapsed seconds since the camera pose last changed. */
+  timeSinceMovement: number;
 };
 
 const scratchVector = new Vector3();
 const scratchPosition = new Vector3();
+const CAMERA_POSITION_EPSILON = 1e-5;
+const CAMERA_DIRECTION_EPSILON = 1e-7;
 const cullingVolume = new CullingVolume([
   new Plane(),
   new Plane(),
@@ -29,12 +72,26 @@ const cullingVolume = new CullingVolume([
   new Plane()
 ]);
 
-// Extracts a frame state appropriate for tile culling from a deck.gl viewport
-// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios
-export function getFrameState(viewport: GeospatialViewport, frameNumber: number): FrameState {
+/**
+ * Extracts a frame state appropriate for tile culling from a structural deck.gl viewport.
+ *
+ * `options.timeSinceCameraMovement` can be supplied by a caller that retains camera pose across
+ * calls. It defaults to a stationary camera so standalone callers do not defer requests.
+ *
+ * @param viewport - Geospatial viewport supplying camera and projection measurements.
+ * @param frameNumber - Current tileset traversal frame number.
+ * @param options - Additional camera and projection measurements for traversal.
+ * @returns Frame state used for visibility, SSE, and request-priority calculations.
+ */
+export function getFrameState(
+  viewport: GeospatialViewport,
+  frameNumber: number,
+  options: GetFrameStateOptions = {}
+): FrameState {
   // Traverse and and request. Update _selectedTiles so that we know what to render.
   // Traverse and and request. Update _selectedTiles so that we know what to render.
-  const {cameraDirection, cameraUp, height} = viewport;
+  const {cameraUp, height} = viewport;
+  const cameraDirection = viewport.cameraDirection as number[] | undefined;
   const {metersPerUnit} = viewport.distanceScales;
 
   // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.
@@ -49,10 +106,26 @@ export function getFrameState(viewport: GeospatialViewport, frameNumber: number)
   );
 
   // These should still be normalized as the transform has scale 1 (goes from meters to meters)
-  const cameraDirectionCartesian = new Vector3(
-    // @ts-ignore
-    enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))
-  ).normalize();
+  let cameraDirectionCartesian: Vector3;
+  if (cameraDirection) {
+    cameraDirectionCartesian = new Vector3(
+      // @ts-ignore
+      enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))
+    ).normalize();
+  } else {
+    // Concrete deck.gl viewports do not expose the legacy structural cameraDirection field.
+    // The near-plane center is on the view axis, so its world-space direction is equivalent and
+    // works for perspective foveation without coupling loaders.gl to deck.gl internals.
+    // getFrustumPlanes is required by traversal but omitted from the minimal structural Viewport
+    // type for compatibility with existing application-side declarations.
+    // @ts-expect-error Runtime geospatial viewports provide getFrustumPlanes.
+    const nearPlane = viewport.getFrustumPlanes().near;
+    const nearCenterCommon = closestPointOnPlane(nearPlane, viewport.cameraPosition);
+    const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+    cameraDirectionCartesian = new Vector3(nearCenterCartesian)
+      .subtract(cameraPositionCartesian)
+      .normalize();
+  }
   const cameraUpCartesian = new Vector3(
     // @ts-ignore
     enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))
@@ -78,14 +151,72 @@ export function getFrameState(viewport: GeospatialViewport, frameNumber: number)
     camera: {
       position: cameraPositionCartesian,
       direction: cameraDirectionCartesian,
-      up: cameraUpCartesian
+      up: cameraUpCartesian,
+      cartographicPosition: cameraPositionCartographic,
+      verticalFieldOfView:
+        Number.isFinite(viewport.fovy) && Number(viewport.fovy) > 0
+          ? (Number(viewport.fovy) * Math.PI) / 180
+          : Math.PI / 3,
+      timeSinceMovement: options.timeSinceCameraMovement ?? Number.POSITIVE_INFINITY
     },
     viewport,
     topDownViewport,
     height,
     cullingVolume,
+    clippingPlanes: viewport.clippingPlanes,
     frameNumber, // TODO: This can be the same between updates, what number is unique for between updates?
-    sseDenominator: 1.15 // Assumes fovy = 60 degrees
+    sseDenominator: 1.15, // Assumes fovy = 60 degrees
+    // Tileset3D fills this immediately before traversal because it depends on the root volume.
+    dynamicScreenSpaceErrorDensity: 0
+  };
+}
+
+/**
+ * Updates retained camera motion state and calculates how long the current pose has been stable.
+ *
+ * The first observation is treated as stationary so initial tileset loading is never delayed.
+ * Position and direction are both compared because orbiting in place changes request relevance
+ * without necessarily changing the viewport's camera position.
+ *
+ * @param previousState - Pose retained from the preceding traversal for this viewport.
+ * @param position - Current Earth-centered, Earth-fixed camera position.
+ * @param direction - Current normalized Earth-centered, Earth-fixed camera direction.
+ * @param currentTime - Current monotonic-enough wall-clock time in milliseconds.
+ * @returns Updated pose and elapsed stationary time.
+ */
+export function updateCameraMotionState(
+  previousState: CameraMotionState | undefined,
+  position: number[] | Vector3,
+  direction: number[] | Vector3,
+  currentTime: number
+): CameraMotionUpdate {
+  const positionArray = Array.from(position);
+  const directionArray = Array.from(direction);
+  const positionChanged = previousState
+    ? positionArray.length !== previousState.position.length ||
+      positionArray.some(
+        (value, index) => Math.abs(value - previousState.position[index]) > CAMERA_POSITION_EPSILON
+      )
+    : false;
+  const directionChanged = previousState
+    ? directionArray.length !== previousState.direction.length ||
+      directionArray.some(
+        (value, index) =>
+          Math.abs(value - previousState.direction[index]) > CAMERA_DIRECTION_EPSILON
+      )
+    : false;
+  const lastMovementTime =
+    positionChanged || directionChanged
+      ? currentTime
+      : (previousState?.lastMovementTime ?? Number.NEGATIVE_INFINITY);
+
+  return {
+    state: {
+      position: positionArray,
+      direction: directionArray,
+      lastMovementTime
+    },
+    timeSinceMovement: Math.max((currentTime - lastMovementTime) / 1000, 0)
   };
 }
 
@@ -162,7 +293,7 @@ function commonSpacePlanesToWGS84(viewport) {
 
 function closestPointOnPlane(
   plane: {distance: number; normal: Vector3},
-  refPoint: [number, number, number] | Vector3,
+  refPoint: number[] | Vector3,
   out: Vector3 = new Vector3()
 ): Vector3 {
   const distanceToRef = plane.normal.dot(refPoint);

package/src/tileset-3d/helpers/i3s-lod.ts

@@ -32,12 +32,25 @@ export function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT
   if (screenSize < 2) {
     return 'OUT';
   }
-  if (!tile.header.children || screenSize <= tile.lodMetricValue) {
+  if (!tile.header.children) {
     return 'DRAW';
-  } else if (tile.header.children) {
-    return 'DIG';
   }
-  return 'OUT';
+
+  switch (tile.lodMetricType) {
+    case 'screenSpaceRelative': {
+      const viewportHeight = frameState.topDownViewport.height || 1;
+      return screenSize / viewportHeight <= tile.lodMetricValue ? 'DRAW' : 'DIG';
+    }
+    case 'distanceRangeFromDefaultCamera':
+      return tile.distanceToTile(frameState) >= tile.lodMetricValue ? 'DRAW' : 'DIG';
+    case 'maxScreenThresholdSQ': {
+      const diameterThreshold = Math.sqrt(tile.lodMetricValue / (Math.PI * 0.25));
+      return screenSize <= diameterThreshold ? 'DRAW' : 'DIG';
+    }
+    case 'maxScreenThreshold':
+    default:
+      return screenSize <= tile.lodMetricValue ? 'DRAW' : 'DIG';
+  }
 }
 
 /**
@@ -49,10 +62,11 @@ export function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT
 // eslint-disable-next-line max-statements
 export function getProjectedRadius(tile: Tile3D, frameState: FrameState): number {
   const {topDownViewport: viewport} = frameState;
-  const mbsLat = tile.header.mbs[1];
-  const mbsLon = tile.header.mbs[0];
-  const mbsZ = tile.header.mbs[2];
-  const mbsR = tile.header.mbs[3];
+  const mbs = tile.header.i3sLodMbs || tile.header.mbs;
+  const mbsLat = mbs[1];
+  const mbsLon = mbs[0];
+  const mbsZ = mbs[2];
+  const mbsR = mbs[3];
   const mbsCenterCartesian = [...tile.boundingVolume.center];
   const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
   Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);