@loaders.gl/tiles 5.0.0-alpha.11 → 5.0.0-alpha.13

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

@@ -1,1056 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-// 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
-import { Vector3, Matrix4 } from '@math.gl/core';
-import { CullingVolume } from '@math.gl/culling';
-import { getTile3DFeatureIdSets } from "./tile-3d-contracts.js";
-import { LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE } from "../../constants.js";
-import { createBoundingVolume, getCartographicBounds } from "../helpers/bounding-volume.js";
-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 isNestedTilesetPayload(payload) {
-    if (!payload || typeof payload !== 'object') {
-        return false;
-    }
-    const record = payload;
-    return record.shape === 'tileset3d' || record.type === 'tileset3d' || Boolean(record.tileset);
-}
-function defined(x) {
-    return x !== undefined && x !== null;
-}
-/**
- * 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.
- * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.
- */
-export class Tile3D {
-    tileset;
-    header;
-    id;
-    url;
-    parent;
-    /* Specifies the type of refine that is used when traversing this tile for rendering. */
-    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';
-    /**
-     * 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 = 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.
-     */
-    _unscaledLodMetricValue = 0;
-    /** Whether the source format defines geometric error in transform-local units. */
-    _scaleGeometricError = true;
-    /** @todo math.gl is not exporting BoundingVolume base type? */
-    boundingVolume = null;
-    /**
-     * The tile's content.  This represents the actual tile's payload,
-     * 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 = [];
-    /** Ordered renderer-neutral descriptors for each source content entry. */
-    contentEntries = [];
-    /** Raw metadata references inherited by this tile and its content. */
-    metadataContext = {};
-    /** Feature-id declarations normalized from supported content extensions. */
-    featureIdSets = [];
-    /** Decoded 3D Tiles vector topology for the primary loaded content, when present. */
-    vectorContent = null;
-    /**
-     * 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();
-    extensions = null;
-    /** TODO Cesium 3d tiles specific */
-    implicitTiling = null;
-    /** Container to store application specific data */
-    userData = {};
-    computedTransform;
-    hasEmptyContent = false;
-    hasTilesetContent = false;
-    traverser = new TilesetTraverser({});
-    /** Used by TilesetCache */
-    _cacheNode = null;
-    _frameNumber = null;
-    // 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;
-    }
-    /** Accumulated tile transforms from the source JSON, excluding the tileset model matrix. */
-    _initialTransform = new Matrix4();
-    // Used by traverser, cannot be marked private
-    _priority = 0;
-    _selectedFrame = 0;
-    _requestedFrame = 0;
-    _selectionDepth = 0;
-    _touchedFrame = 0;
-    _centerZDepth = 0;
-    _shouldRefine = false;
-    _stackLength = 0;
-    _visitedFrame = 0;
-    _inRequestVolume = false;
-    _lodJudge = null; // TODO i3s specific, needs to remove
-    /**
-     * Indicates whether the tile has been drawn by the renderer.
-     * Defaults to true for backwards compatibility — renderers that support
-     * transition hold (e.g. deck.gl 9.3+) should set this to false on tile load,
-     * then back to true after first draw to avoid flashes (see deck.gl #7914).
-     */
-    tileDrawn = true;
-    /**
-     * @constructs
-     * Create a Tile3D instance
-     * @param tileset - Tileset3D instance
-     * @param header - tile header - JSON loaded from a dataset
-     * @param parentHeader - parent Tile3D instance
-     * @param extendedId - optional ID to separate copies of a tile for different viewports.
-     *    const extendedId = `${tile.id}-${frameState.viewport.id}`;
-     */
-    // eslint-disable-next-line max-statements
-    constructor(tileset, header, parentHeader, extendedId = '') {
-        // PUBLIC MEMBERS
-        // original tile data
-        this.header = header;
-        // The tileset containing this tile.
-        this.tileset = tileset;
-        this.id = extendedId || header.id;
-        this.url = header.url;
-        // This tile's parent or `undefined` if this tile is the root.
-        // @ts-ignore
-        this.parent = parentHeader;
-        this.refine = this._getRefine(header.refine);
-        this.type = header.type;
-        this.contentUrl = header.contentUrl;
-        this.contentUrls = header.contentUrls || (header.contentUrl ? [header.contentUrl] : []);
-        this._initializeMetadata(header);
-        this.childrenState = header.implicitSubtree ? 'unloaded' : 'ready';
-        this._initializeLodMetric(header);
-        this._initializeTransforms(header);
-        this._updateLodMetricScale();
-        this._initializeBoundingVolumes(header);
-        this._initializeContent(header);
-        this._initializeContentEntries(header);
-        this._initializeRenderingState(header);
-        Object.seal(this);
-    }
-    destroy() {
-        this.header = null;
-    }
-    isDestroyed() {
-        return this.header === null;
-    }
-    get selected() {
-        return this._selectedFrame === this.tileset._frameNumber;
-    }
-    get isVisible() {
-        return this._visible;
-    }
-    get isVisibleAndInRequestVolume() {
-        return this._visible && this._inRequestVolume;
-    }
-    /** Returns true if tile is not an empty tile and not an external tileset */
-    get hasRenderContent() {
-        return !this.hasEmptyContent && !this.hasTilesetContent;
-    }
-    /** Returns true if tile has children */
-    get hasChildren() {
-        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
-     * tiles with empty content.
-     */
-    get contentReady() {
-        return this.contentState === TILE_CONTENT_STATE.READY || this.hasEmptyContent;
-    }
-    /**
-     * Determines if the tile has available content to render.  `true` if the tile's
-     * content is ready or if it has expired content this renders while new content loads; otherwise,
-     */
-    get contentAvailable() {
-        return Boolean((this.contentReady && this.hasRenderContent) || (this._expiredContent && !this.contentFailed));
-    }
-    /** Returns true if tile has renderable content but it's unloaded */
-    get hasUnloadedContent() {
-        return this.hasRenderContent && this.contentUnloaded;
-    }
-    /**
-     * Determines if the tile's content has not be requested. `true` if tile's
-     * content has not be requested; otherwise, `false`.
-     */
-    get contentUnloaded() {
-        return this.contentState === TILE_CONTENT_STATE.UNLOADED;
-    }
-    /**
-     * Determines if the tile's content is expired. `true` if tile's
-     * content is expired; otherwise, `false`.
-     */
-    get contentExpired() {
-        return this.contentState === TILE_CONTENT_STATE.EXPIRED;
-    }
-    // Determines if the tile's content failed to load.  `true` if the tile's
-    // content failed to load; otherwise, `false`.
-    get contentFailed() {
-        return this.contentState === TILE_CONTENT_STATE.FAILED;
-    }
-    /**
-     * Distance from the tile's bounding volume center to the camera
-     */
-    get distanceToCamera() {
-        return this._distanceToCamera;
-    }
-    /**
-     * Screen space error for LOD selection
-     */
-    get screenSpaceError() {
-        return this._screenSpaceError;
-    }
-    /**
-     * Get the current world-space bounding volume in cartographic coordinates.
-     * @returns [min, max] each in [longitude, latitude, altitude]
-     */
-    get boundingBox() {
-        if (!this._boundingBox) {
-            this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume, !this.computedTransform.equals(this._initialTransform));
-        }
-        return this._boundingBox;
-    }
-    /**
-     * 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, viewportHeightFraction);
-            default:
-                // eslint-disable-next-line
-                throw new Error('Unsupported tileset type');
-        }
-    }
-    /**
-     * Make tile unselected than means it won't be shown
-     * but it can be still loaded in memory
-     */
-    unselect() {
-        this._selectedFrame = 0;
-    }
-    /**
-     * Memory usage of tile on GPU
-     */
-    _getGpuMemoryUsageInBytes() {
-        const contents = this.contents.length ? this.contents : [this.content];
-        return contents.reduce((total, content) => total + (content?.gpuMemoryUsageInBytes || content?.byteLength || 0), 0);
-    }
-    /**
-     * Returns scheduler priority for render-content requests.
-     *
-     * @returns Numeric priority, or a negative value when the queued request should be cancelled.
-     */
-    _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.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
-        /*
-         * Tiles that are outside of the camera's frustum could be skipped if we are in 'ADD' mode
-         * or if we are using 'Skip Traversal' in 'REPLACE' mode.
-         * Otherewise, all 'touched' child tiles have to be loaded and displayed,
-         * this may include tiles that are outide of the camera frustum (so that we can hide the parent tile).
-         */
-        const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
-        // Check if any reason to abort
-        if (maySkipTile && !this.isVisible && this._visible !== undefined) {
-            return -1;
-        }
-        // Condition used in `cancelOutOfViewRequests` function in CesiumJS/Cesium3DTileset.js
-        if (this.tileset._frameNumber - this._touchedFrame >= 1) {
-            return -1;
-        }
-        // 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.
-        const parent = this.parent;
-        const useParentScreenSpaceError = parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);
-        const screenSpaceError = useParentScreenSpaceError
-            ? 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), 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.
-     * The request may not be made if the Request Scheduler can't prioritize it.
-     */
-    // eslint-disable-next-line max-statements, complexity
-    async loadContent() {
-        if (this.hasEmptyContent) {
-            return { loaded: false };
-        }
-        if (this.content) {
-            return { loaded: true };
-        }
-        const expired = this.contentExpired;
-        if (expired) {
-            this._expireDate = null;
-        }
-        this.contentState = TILE_CONTENT_STATE.LOADING;
-        const requestToken = await this.tileset._requestScheduler.scheduleRequest(this.id, this._getPriority.bind(this));
-        if (!requestToken) {
-            // cancelled
-            this.contentState = TILE_CONTENT_STATE.UNLOADED;
-            return { loaded: false };
-        }
-        try {
-            return await this._loadContentFromSource();
-        }
-        catch (error) {
-            // Tile is unloaded before the content finishes loading
-            this.contentState = TILE_CONTENT_STATE.FAILED;
-            throw error;
-        }
-        finally {
-            requestToken.done();
-        }
-    }
-    /** Loads content for complete dataset operations without viewport-based request priority. */
-    async loadContentForTraversal() {
-        if (this.hasEmptyContent) {
-            return { loaded: false };
-        }
-        if (this.content) {
-            return { loaded: true, contents: this.contents };
-        }
-        this.contentState = TILE_CONTENT_STATE.LOADING;
-        try {
-            return await this._loadContentFromSource();
-        }
-        catch (error) {
-            this.contentState = TILE_CONTENT_STATE.FAILED;
-            throw error;
-        }
-    }
-    /** Loads source content and updates the tile's renderer-neutral payload state. */
-    async _loadContentFromSource() {
-        const loadResult = await this.tileset.source.loadTileContent(this);
-        if (loadResult.contents) {
-            this.contents = loadResult.contents;
-            this.content = this.contents[0] || null;
-        }
-        this.vectorContent =
-            this.contents.find(content => Boolean(content?.vectorContent))?.vectorContent || null;
-        if (this.tileset.options.contentLoader) {
-            await this.tileset.options.contentLoader(this);
-        }
-        this.contentState = TILE_CONTENT_STATE.READY;
-        this._onContentLoaded();
-        this._updateContentEntriesAfterLoad(loadResult);
-        return loadResult;
-    }
-    /**
-     * 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.
-     *
-     * The placeholder transform is preserved when the subtree omits a root transform. An explicit
-     * subtree-root transform replaces it and is recomposed against the runtime parent. Content,
-     * metadata, bounds, and raw geometric error are reinitialized from the available header.
-     *
-     * @param materializedHeader - Available root header produced from one subtree resource.
-     */
-    applyImplicitSubtreeHeader(materializedHeader) {
-        const existingTransform = this.header.transform;
-        const existingTransformMatrix = this.header.transformMatrix;
-        const hasMaterializedTransform = materializedHeader.transform !== undefined;
-        this.header = {
-            ...this.header,
-            ...materializedHeader,
-            transform: hasMaterializedTransform ? materializedHeader.transform : existingTransform,
-            transformMatrix: hasMaterializedTransform
-                ? materializedHeader.transformMatrix
-                : existingTransformMatrix,
-            implicitSubtree: undefined
-        };
-        if (hasMaterializedTransform) {
-            this._initializeTransforms(this.header);
-        }
-        this.refine = this._getRefine(materializedHeader.refine);
-        this.type = materializedHeader.type;
-        this.contentUrl = materializedHeader.contentUrl;
-        this.contentUrls =
-            materializedHeader.contentUrls ||
-                (materializedHeader.contentUrl ? [materializedHeader.contentUrl] : []);
-        this._initializeMetadata(this.header);
-        this._initializeLodMetric(materializedHeader);
-        this._updateLodMetricScale();
-        this._initializeBoundingVolumes(this.header);
-        this._boundingBox = undefined;
-        // 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);
-        this._initializeContentEntries(this.header);
-    }
-    /** Refreshes tile and content metadata from a source or materialized tile header. */
-    _initializeMetadata(header) {
-        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);
-        const firstContentHeader = contentHeaders.find(Boolean) || {};
-        const groupReference = firstContentHeader.group;
-        const group = typeof groupReference === 'number'
-            ? this.tileset.groups?.[groupReference] || null
-            : groupReference || null;
-        const metadataContext = {
-            tileset: this.tileset.metadata || null,
-            group,
-            tile: this.metadata,
-            content: this.contentMetadata[0] || null,
-            subtree: header.implicitMetadata || null
-        };
-        if (this.tileset.groups) {
-            metadataContext.groups = this.tileset.groups;
-        }
-        this.metadataContext = metadataContext;
-    }
-    /** Updates payload and renderability while retaining immutable metadata descriptors. */
-    _updateContentEntriesAfterLoad(loadResult) {
-        if (loadResult.contentEntries) {
-            this.contentEntries = loadResult.contentEntries.map((entry, index) => ({
-                ...entry,
-                index,
-                boundingVolume: entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
-                payload: entry.payload ?? this.contents[index] ?? null,
-                featureIds: entry.featureIds?.length
-                    ? entry.featureIds
-                    : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
-                renderable: Boolean(entry.renderable !== false &&
-                    (entry.payload ?? this.contents[index]) &&
-                    !isNestedTilesetPayload(entry.payload ?? this.contents[index]))
-            }));
-            this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
-            return;
-        }
-        this.contentEntries = this.contentEntries.map((entry, index) => ({
-            ...entry,
-            payload: this.contents[index] ?? null,
-            featureIds: getTile3DFeatureIdSets(this.contents[index]),
-            renderable: Boolean(this.contents[index]) && !isNestedTilesetPayload(this.contents[index])
-        }));
-        this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
-    }
-    /** Returns one ordered content descriptor, or null when the index is out of range. */
-    getContentEntry(index) {
-        return this.contentEntries[index] || null;
-    }
-    /** Returns whether an ordered content entry currently has renderable payload. */
-    isContentRenderable(index) {
-        return Boolean(this.contentEntries[index]?.renderable);
-    }
-    /** Initializes additive renderer-neutral descriptors from a normalized tile header. */
-    _initializeContentEntries(tileHeader) {
-        const headers = Array.isArray(tileHeader.content)
-            ? tileHeader.content
-            : tileHeader.content
-                ? [tileHeader.content]
-                : [];
-        this.contentEntries = headers.map((contentHeader, index) => {
-            const normalizedContentHeader = contentHeader || {};
-            return {
-                index,
-                uri: this.contentUrls[index] || normalizedContentHeader.uri || normalizedContentHeader.url,
-                group: normalizedContentHeader.group,
-                type: normalizedContentHeader.type,
-                payload: null,
-                metadata: normalizedContentHeader.metadata || null,
-                boundingVolume: this._contentBoundingVolumes[index] || this.boundingVolume,
-                featureIds: this._getFeatureIdSets(normalizedContentHeader),
-                renderable: false
-            };
-        });
-    }
-    /** Extracts renderer-neutral feature-id declarations without decoding property values. */
-    _getFeatureIdSets(contentHeader) {
-        return getTile3DFeatureIdSets(contentHeader);
-    }
-    // Unloads the tile's content.
-    unloadContent() {
-        for (const content of this.contents.length ? this.contents : [this.content]) {
-            if (content && content.destroy) {
-                content.destroy();
-            }
-        }
-        this.contents = [];
-        this.content = null;
-        this.vectorContent = null;
-        this.contentEntries = this.contentEntries.map(entry => ({
-            ...entry,
-            payload: null,
-            renderable: false
-        }));
-        this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
-        if (this.header.content && this.header.content.destroy) {
-            this.header.content.destroy();
-        }
-        this.header.content = null;
-        this.contentState = TILE_CONTENT_STATE.UNLOADED;
-        this.tileDrawn = true;
-        return true;
-    }
-    /**
-     * Update the tile's visibility
-     * @param {Object} frameState - frame state for tile culling
-     * @param {string[]} viewportIds - a list of viewport ids that show this tile
-     * @return {void}
-     */
-    updateVisibility(frameState, viewportIds) {
-        if (this._frameNumber === frameState.frameNumber) {
-            // Return early if visibility has already been checked during the traversal.
-            // The visibility may have already been checked if the cullWithChildrenBounds optimization is used.
-            return;
-        }
-        const parent = this.parent;
-        const parentVisibilityPlaneMask = parent
-            ? parent._visibilityPlaneMask
-            : CullingVolume.MASK_INDETERMINATE;
-        if (this.tileset._traverser.options.updateTransforms) {
-            const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;
-            this._updateTransform(parentTransform);
-        }
-        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 traverser = this.tileset._traverser;
-        const skipLevelOfDetail = traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
-        const deferralEligible = isFoveatedRequestDeferred({
-            refinement: this.refine,
-            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.
-    // @returns {Number} A plane mask as described above in {@link CullingVolume#computeVisibilityWithPlaneMask}.
-    visibility(frameState, parentVisibilityPlaneMask) {
-        const { cullingVolume } = frameState;
-        const { boundingVolume } = this;
-        // TODO Cesium specific - restore clippingPlanes
-        // const {clippingPlanes, clippingPlanesOriginMatrix} = tileset;
-        // if (clippingPlanes && clippingPlanes.enabled) {
-        //   const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(
-        //     boundingVolume,
-        //     clippingPlanesOriginMatrix
-        //   );
-        //   this._isClipped = intersection !== Intersect.INSIDE;
-        //   if (intersection === Intersect.OUTSIDE) {
-        //     return CullingVolume.MASK_OUTSIDE;
-        //   }
-        // }
-        // return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
-        return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
-    }
-    /**
-     * 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, contentIndex) {
-        const contentVolumes = contentIndex === undefined
-            ? this._contentBoundingVolumes
-            : this._contentBoundingVolumes[contentIndex]
-                ? [this._contentBoundingVolumes[contentIndex]]
-                : [];
-        return getContentVisibility(contentVolumes, 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.
-     * @param frameState The frame state.
-     * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.
-     */
-    distanceToTile(frameState) {
-        const boundingVolume = this.boundingVolume;
-        return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));
-    }
-    /**
-     * Computes the tile's camera-space z-depth.
-     * @param frameState The frame state.
-     * @returns The distance, in meters.
-     */
-    cameraSpaceZDepth({ camera }) {
-        const boundingVolume = this.boundingVolume; // Gets the underlying OrientedBoundingBox or BoundingSphere
-        scratchVector.subVectors(boundingVolume.center, camera.position);
-        return camera.direction.dot(scratchVector);
-    }
-    /**
-     * Checks if the camera is inside the viewer request volume.
-     * @param {FrameState} frameState The frame state.
-     * @returns {Boolean} Whether the camera is inside the volume.
-     */
-    insideViewerRequestVolume(frameState) {
-        const viewerRequestVolume = this._viewerRequestVolume;
-        return (!viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0);
-    }
-    // TODO Cesium specific
-    // Update whether the tile has expired.
-    updateExpiration() {
-        if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
-            const now = Date.now();
-            // @ts-ignore Date.lessThan - replace with ms compare?
-            if (Date.lessThan(this._expireDate, now)) {
-                this.contentState = TILE_CONTENT_STATE.EXPIRED;
-                this._expiredContent = this.content;
-            }
-        }
-    }
-    get extras() {
-        return this.header.extras;
-    }
-    // INTERNAL METHODS
-    /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
-    _initializeLodMetric(header) {
-        this._scaleGeometricError =
-            typeof header._scaleGeometricError === 'boolean'
-                ? header._scaleGeometricError
-                : (this.parent?._scaleGeometricError ?? true);
-        if ('lodMetricType' in header) {
-            this.lodMetricType = header.lodMetricType;
-        }
-        else {
-            this.lodMetricType = (this.parent && this.parent.lodMetricType) || this.tileset.lodMetricType;
-            // eslint-disable-next-line
-            console.warn(`3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType`);
-        }
-        // This is used to compute screen space error, i.e., the error measured in pixels.
-        if ('lodMetricValue' in header) {
-            this._unscaledLodMetricValue = header.lodMetricValue;
-        }
-        else {
-            // 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) {
-        // The local transform of this tile.
-        this.transform = tileHeader.transform ? new Matrix4(tileHeader.transform) : new Matrix4();
-        const parent = this.parent;
-        const tileset = this.tileset;
-        const parentTransform = parent && parent.computedTransform
-            ? parent.computedTransform.clone()
-            : tileset.modelMatrix.clone();
-        this.computedTransform = new Matrix4(parentTransform).multiplyRight(this.transform);
-        const parentInitialTransform = parent && parent._initialTransform ? parent._initialTransform.clone() : new Matrix4();
-        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() {
-        if (this.lodMetricType !== LOD_METRIC_TYPE.GEOMETRIC_ERROR || !this._scaleGeometricError) {
-            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._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 || tileHeader.contentUrls?.length) {
-            this.content = null;
-            this.hasEmptyContent = false;
-        }
-    }
-    // TODO - remove anything not related to basic visibility detection
-    _initializeRenderingState(header) {
-        this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);
-        this._shouldRefine = false;
-        // Members this are updated every frame for tree traversal and rendering optimizations:
-        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;
-        this._stackLength = 0;
-        this._selectionDepth = 0;
-        this._frameNumber = 0;
-        this._touchedFrame = 0;
-        this._visitedFrame = 0;
-        this._selectedFrame = 0;
-        this._requestedFrame = 0;
-        this._priority = 0.0;
-    }
-    _getRefine(refine) {
-        // 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.contents.length ? this.contents : [this.content]).some(content => content?.shape === 'tileset3d');
-    }
-    _onContentLoaded() {
-        // Vector and Geometry tile rendering do not support the skip LOD optimization.
-        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()) {
-            this.hasTilesetContent = true;
-        }
-        else {
-            this.gpuMemoryUsageInBytes = this._getGpuMemoryUsageInBytes();
-        }
-    }
-    _updateBoundingVolume(header) {
-        this._boundingBox = undefined;
-        // Update the bounding volumes
-        this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume, this._initialTransform);
-        // 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, this._initialTransform);
-        }
-        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, undefined, this._initialTransform)
-                : this.boundingVolume)
-            : [this.boundingVolume];
-        this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
-    }
-    /**
-     * 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()) {
-        const computedTransform = parentTransform.clone().multiplyRight(this.transform);
-        const didTransformChange = !computedTransform.equals(this.computedTransform);
-        if (!didTransformChange) {
-            return;
-        }
-        this.computedTransform = computedTransform;
-        // Recalculate from the unscaled source metric so repeated model-matrix changes never compound.
-        this._updateLodMetricScale();
-        this._updateBoundingVolume(this.header);
-    }
-}
-//# sourceMappingURL=tile-3d.js.map