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

package/dist/tileset-3d/common/tile-3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tile-3d.d.ts","sourceRoot":"","sources":["../../../src/tileset-3d/common/tile-3d.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tile-3d.d.ts","sourceRoot":"","sources":["../../../src/tileset-3d/common/tile-3d.ts"],"names":[],"mappings":"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"}

package/dist/tileset-3d/common/tile-3d.js

@@ -10,7 +10,52 @@ import { createBoundingVolume, getCartographicBounds } from "../helpers/bounding
 import { getTiles3DScreenSpaceError } from "../helpers/tiles-3d-lod.js";
 import { getProjectedRadius } from "../helpers/i3s-lod.js";
 import { TilesetTraverser } from "./tileset-traverser.js";
+import { calculateFoveatedFactor, calculateTileRequestPriority, isFoveatedRequestDelayActive, isFoveatedRequestDeferred, isProgressiveResolutionPriority } from "../helpers/tiles-3d-request-priority.js";
 const scratchVector = new Vector3();
+/**
+ * Classifies render-content visibility across all content volumes owned by a tile.
+ *
+ * Content volumes form a union: one visible content entry keeps the tile renderable even when
+ * another entry is outside the frustum or clipping planes. The traversal volume is intentionally
+ * not used here except as a fallback when a tile has no content-specific volume. This separation
+ * keeps clipping render-only and prevents a tight content volume from pruning descendants.
+ *
+ * @param contentVolumes - Transformed content volumes in source order.
+ * @param fallbackVolume - Tile volume used when content does not declare its own volume.
+ * @param cullingVolume - Current view frustum.
+ * @param visibilityPlaneMask - Parent visibility mask optimization.
+ * @param clippingPlanes - Optional world-space planes applied to render content only.
+ * @returns Union visibility classification for the renderable content.
+ */
+export function getContentVisibility(contentVolumes, fallbackVolume, cullingVolume, visibilityPlaneMask, clippingPlanes = []) {
+    const volumes = contentVolumes.length ? contentVolumes : [fallbackVolume];
+    let visibleVolume = false;
+    let intersectingVolume = false;
+    for (const contentVolume of volumes) {
+        let visibility = 'inside';
+        if (visibilityPlaneMask !== CullingVolume.MASK_INSIDE) {
+            visibility = cullingVolume.computeVisibility(contentVolume);
+            if (visibility === 'outside') {
+                continue;
+            }
+        }
+        let clipped = false;
+        for (const clippingPlane of clippingPlanes) {
+            if (contentVolume.intersectPlane(clippingPlane) === 'outside') {
+                clipped = true;
+                break;
+            }
+        }
+        if (!clipped) {
+            visibleVolume = true;
+            intersectingVolume = intersectingVolume || visibility === 'intersecting';
+        }
+    }
+    if (!visibleVolume) {
+        return 'outside';
+    }
+    return intersectingVolume ? 'intersecting' : 'inside';
+}
 function defined(x) {
     return x !== undefined && x !== null;
 }
@@ -29,6 +74,8 @@ export class Tile3D {
     refine;
     type;
     contentUrl;
+    /** Resolved render-content URLs in source order; empty for contentless tiles. */
+    contentUrls = [];
     /** Different refinement algorithms used by I3S and 3D tiles */
     lodMetricType = 'geometricError';
     /**
@@ -48,10 +95,23 @@ export class Tile3D {
      * not the content's metadata in the tileset JSON file.
      */
     content = null;
+    /** Loaded payloads in the same order as {@link contentUrls}; `content` remains the primary payload. */
+    contents = [];
+    /**
+     * Metadata entity attached to this tile in the source tileset, if present.
+     *
+     * This is the raw 3D Tiles metadata reference. The generic tiles runtime preserves it without
+     * decoding schema classes or binary property tables.
+     */
+    metadata = null;
+    /** Raw metadata entities attached to tile contents, in content source order. */
+    contentMetadata = [];
     contentState = TILE_CONTENT_STATE.UNLOADED;
     gpuMemoryUsageInBytes = 0;
     /** The tile's children - an array of Tile3D objects. */
     children = [];
+    /** Current lifecycle state for a lazy implicit subtree rooted at this tile. */
+    childrenState = 'ready';
     depth = 0;
     viewportIds = [];
     transform = new Matrix4();
@@ -70,14 +130,39 @@ export class Tile3D {
     // TODO Cesium 3d tiles specific
     _expireDate = null;
     _expiredContent = null;
+    /** In-flight source request shared by repeated traversal frames. */
+    _childrenPromise = null;
     _boundingBox = undefined;
     /** updated every frame for tree traversal and rendering optimizations: */
     _distanceToCamera = 0;
     _screenSpaceError = 0;
+    /** SSE calculated at the reduced viewport height used to prioritize coarse coverage. */
+    _screenSpaceErrorProgressiveResolution = 0;
+    /** Whether this tile should be promoted into the progressive-resolution request pass. */
+    _priorityProgressiveResolution = false;
+    /** Angular distance from the camera view axis used to prioritize center tiles. */
+    _foveatedFactor = 0;
+    /** Whether this peripheral request is currently inside the camera-motion deferral window. */
+    priorityDeferred = false;
     _visibilityPlaneMask;
     _visible = undefined;
     _contentBoundingVolume;
+    _contentBoundingVolumes = [];
+    /** Source content-volume headers retained after render content is unloaded. */
+    _contentBoundingVolumeHeaders = [];
     _viewerRequestVolume;
+    /** Bounding volume used to cull the tile's first renderable content entry. */
+    get contentBoundingVolume() {
+        return this._contentBoundingVolume;
+    }
+    /** All transformed render-content bounding volumes, including tile-volume fallbacks. */
+    get contentBoundingVolumes() {
+        return this._contentBoundingVolumes;
+    }
+    /** Bounding volume that limits when this tile may be requested, when declared. */
+    get viewerRequestVolume() {
+        return this._viewerRequestVolume;
+    }
     _initialTransform = new Matrix4();
     // Used by traverser, cannot be marked private
     _priority = 0;
@@ -122,6 +207,13 @@ export class Tile3D {
         this.refine = this._getRefine(header.refine);
         this.type = header.type;
         this.contentUrl = header.contentUrl;
+        this.contentUrls = header.contentUrls || (header.contentUrl ? [header.contentUrl] : []);
+        this.metadata = header.metadata || null;
+        const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
+        this.contentMetadata = contentHeaders
+            .filter(Boolean)
+            .map(contentHeader => contentHeader.metadata || null);
+        this.childrenState = header.implicitSubtree ? 'unloaded' : 'ready';
         this._initializeLodMetric(header);
         this._initializeTransforms(header);
         this._updateLodMetricScale();
@@ -151,7 +243,18 @@ 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() {
+        return Boolean(this.header.implicitSubtree &&
+            (this.childrenState === 'unloaded' || this.childrenState === 'failed'));
+    }
+    /** Returns whether a lazy child-header request is currently in flight. */
+    get childrenLoading() {
+        return this.childrenState === 'loading';
     }
     /**
      * Determines if the tile's content is ready. This is automatically `true` for
@@ -212,13 +315,23 @@ 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');
@@ -235,14 +348,37 @@ export class Tile3D {
      * Memory usage of tile on GPU
      */
     _getGpuMemoryUsageInBytes() {
-        return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
+        const contents = this.contents.length ? this.contents : [this.content];
+        return contents.reduce((total, content) => total + (content?.gpuMemoryUsageInBytes || content?.byteLength || 0), 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.
      */
-    // eslint-disable-next-line complexity
     _getPriority() {
+        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.
+     */
+    _getChildrenPriority() {
+        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
+    _calculateRequestPriority(allowUnloadedContent) {
         const traverser = this.tileset._traverser;
         const { skipLevelOfDetail } = traverser.options;
         /*
@@ -260,7 +396,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;
         }
         // Based on the priority function `getPriorityReverseScreenSpaceError` in CesiumJS. Scheduling priority is based on the parent's screen space error when possible.
@@ -270,8 +412,15 @@ export class Tile3D {
             ? parent._screenSpaceError
             : this._screenSpaceError;
         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
+        });
     }
     /**
      *  Requests the tile's content.
@@ -298,6 +447,10 @@ export class Tile3D {
         }
         try {
             const loadResult = await this.tileset.source.loadTileContent(this);
+            if (loadResult.contents) {
+                this.contents = loadResult.contents;
+                this.content = this.contents[0] || null;
+            }
             if (this.tileset.options.contentLoader) {
                 await this.tileset.options.contentLoader(this);
             }
@@ -314,11 +467,100 @@ export class Tile3D {
             requestToken.done();
         }
     }
+    /**
+     * 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) {
+        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.
+     */
+    async _loadChildrenWithScheduler(frameState) {
+        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) {
+        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.contentUrls =
+            materializedHeader.contentUrls ||
+                (materializedHeader.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) {
-            this.content.destroy();
+        for (const content of this.contents.length ? this.contents : [this.content]) {
+            if (content && content.destroy) {
+                content.destroy();
+            }
         }
+        this.contents = [];
         this.content = null;
         if (this.header.content && this.header.content.destroy) {
             this.header.content.destroy();
@@ -350,12 +592,59 @@ 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);
         this._frameNumber = frameState.frameNumber;
         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) {
+        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.
@@ -378,46 +667,16 @@ export class Tile3D {
         // return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
         return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
     }
-    // Assuming the tile's bounding volume intersects the culling volume, determines
-    // whether the tile's content's bounding volume intersects the culling volume.
-    // @param {FrameState} frameState The frame state.
-    // @returns {Intersect} The result of the intersection: the tile's content is completely outside, completely inside, or intersecting the culling volume.
-    contentVisibility() {
-        return true;
-        // TODO restore
-        /*
-        // Assumes the tile's bounding volume intersects the culling volume already, so
-        // just return Intersect.INSIDE if there is no content bounding volume.
-        if (!defined(this.contentBoundingVolume)) {
-          return Intersect.INSIDE;
-        }
-    
-        if (this._visibilityPlaneMask === CullingVolume.MASK_INSIDE) {
-          // The tile's bounding volume is completely inside the culling volume so
-          // the content bounding volume must also be inside.
-          return Intersect.INSIDE;
-        }
-    
-        // PERFORMANCE_IDEA: is it possible to burn less CPU on this test since we know the
-        // tile's (not the content's) bounding volume intersects the culling volume?
-        const cullingVolume = frameState.cullingVolume;
-        const boundingVolume = tile.contentBoundingVolume;
-    
-        const tileset = this.tileset;
-        const clippingPlanes = tileset.clippingPlanes;
-        if (defined(clippingPlanes) && clippingPlanes.enabled) {
-          const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(
-            boundingVolume,
-            tileset.clippingPlanesOriginMatrix
-          );
-          this._isClipped = intersection !== Intersect.INSIDE;
-          if (intersection === Intersect.OUTSIDE) {
-            return Intersect.OUTSIDE;
-          }
-        }
-    
-        return cullingVolume.computeVisibility(boundingVolume);
-        */
+    /**
+     * Determines whether renderable content intersects the view and configured clipping planes.
+     *
+     * Clipping planes are render-only constraints; traversal continues to use the tile volume.
+     *
+     * @param frameState Current camera, culling, and optional clipping-plane state.
+     * @returns The content visibility classification.
+     */
+    contentVisibility(frameState) {
+        return getContentVisibility(this._contentBoundingVolumes, this.boundingVolume, frameState.cullingVolume, this._visibilityPlaneMask, frameState.clippingPlanes);
     }
     /**
      * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
@@ -522,18 +781,20 @@ export class Tile3D {
     }
     _initializeBoundingVolumes(tileHeader) {
         this._contentBoundingVolume = null;
+        this._contentBoundingVolumeHeaders = [];
         this._viewerRequestVolume = null;
         this._updateBoundingVolume(tileHeader);
     }
     _initializeContent(tileHeader) {
         // Empty tile by default
         this.content = { _tileset: this.tileset, _tile: this };
+        this.contents = [];
         this.hasEmptyContent = true;
         this.contentState = TILE_CONTENT_STATE.UNLOADED;
         // When `true`, the tile's content points to an external tileset.
         // This is `false` until the tile's content is loaded.
         this.hasTilesetContent = false;
-        if (tileHeader.contentUrl) {
+        if (tileHeader.contentUrl || tileHeader.contentUrls?.length) {
             this.content = null;
             this.hasEmptyContent = false;
         }
@@ -546,6 +807,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;
@@ -562,18 +827,28 @@ export class Tile3D {
         // Inherit from parent tile if omitted.
         return refine || (this.parent && this.parent.refine) || TILE_REFINEMENT.REPLACE;
     }
+    /**
+     * 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() {
-        return this.contentUrl.indexOf('.json') !== -1;
+        return (this.contents.length ? this.contents : [this.content]).some(content => content?.shape === 'tileset3d');
     }
     _onContentLoaded() {
         // Vector and Geometry tile rendering do not support the skip LOD optimization.
-        switch (this.content && this.content.type) {
-            case 'vctr':
-            case 'geom':
-                // @ts-ignore
-                this.tileset._traverser.disableSkipLevelOfDetail = true;
-                break;
-            default:
+        const contents = this.contents.length ? this.contents : [this.content];
+        for (const content of contents) {
+            switch (content && content.type) {
+                case 'vctr':
+                case 'geom':
+                    // @ts-ignore
+                    this.tileset._traverser.disableSkipLevelOfDetail = true;
+                    break;
+                default:
+            }
         }
         // The content may be tileset json
         if (this._isTileset()) {
@@ -586,22 +861,29 @@ export class Tile3D {
     _updateBoundingVolume(header) {
         // Update the bounding volumes
         this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume);
-        const content = header.content;
-        if (!content) {
-            return;
-        }
-        // TODO Cesium specific
-        // Non-leaf tiles may have a content bounding-volume, which is a tight-fit bounding volume
-        // around only the features in the tile. This box is useful for culling for rendering,
-        // but not for culling for traversing the tree since it does not guarantee spatial coherence, i.e.,
-        // since it only bounds features in the tile, not the entire tile, children may be
-        // outside of this box.
-        if (content.boundingVolume) {
-            this._contentBoundingVolume = createBoundingVolume(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
-        }
+        // 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) {
+            this._contentBoundingVolumeHeaders = Array.isArray(content) ? content : [content];
+        }
+        const contentHeaders = content
+            ? Array.isArray(content)
+                ? content
+                : [content]
+            : this._contentBoundingVolumeHeaders;
+        // Preserve source order: an unbounded content entry uses the tile volume at its
+        // corresponding index rather than being appended after bounded sibling entries.
+        this._contentBoundingVolumes = contentHeaders.length
+            ? contentHeaders.map(headerEntry => headerEntry?.boundingVolume
+                ? createBoundingVolume(headerEntry.boundingVolume, this.computedTransform)
+                : this.boundingVolume)
+            : [this.boundingVolume];
+        this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
     }
     /**
      * Updates the tile's computed transform, world-space geometric error, and bounding volumes.