@loaders.gl/tiles 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/tileset/helpers/tiles-3d-lod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiles-3d-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/tiles-3d-lod.ts"],"names":[],"mappings":"AAkBA,wBAAgB,gCAAgC,CAAC,IAAI,KAAA,EAAE,EAAC,MAAM,EAAE,aAAa,EAAC;;;CAAA,EAAE,OAAO,KAAK,UAqF3F;AAED,wBAAgB,GAAG,CAAC,gBAAgB,KAAA,EAAE,OAAO,KAAA,UAG5C;AAED,wBAAgB,0BAA0B,CAAC,OAAO,KAAA,EAAE,gBAAgB,KAAA,UAUnE;AAED,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,kBAAkB,KAAA,UAsB9E"}

package/dist/tileset/helpers/tiles-3d-lod.js

@@ -1,105 +1,116 @@
-import { Matrix4, Vector3, clamp } from '@math.gl/core';
-const scratchPositionNormal = new Vector3();
-const scratchCartographic = new Vector3();
-const scratchMatrix = new Matrix4();
-const scratchCenter = new Vector3();
-const scratchPosition = new Vector3();
-const scratchDirection = new Vector3();
-export function calculateDynamicScreenSpaceError(root, {
-  camera,
-  mapProjection
-}, options = {}) {
-  const {
-    dynamicScreenSpaceErrorHeightFalloff = 0.25,
-    dynamicScreenSpaceErrorDensity = 0.00278
-  } = options;
-  let up;
-  let direction;
-  let height;
-  let minimumHeight;
-  let maximumHeight;
-  const tileBoundingVolume = root.contentBoundingVolume;
-
-  if (tileBoundingVolume instanceof TileBoundingRegion) {
-    up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
-    direction = camera.directionWC;
-    height = camera.positionCartographic.height;
-    minimumHeight = tileBoundingVolume.minimumHeight;
-    maximumHeight = tileBoundingVolume.maximumHeight;
-  } else {
-    const transformLocal = Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);
-    const ellipsoid = mapProjection.ellipsoid;
-    const boundingVolume = tileBoundingVolume.boundingVolume;
-    const centerLocal = Matrix4.multiplyByPoint(transformLocal, boundingVolume.center, scratchCenter);
-
-    if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {
-      const centerCartographic = Cartographic.fromCartesian(centerLocal, ellipsoid, scratchCartographic);
-      up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
-      direction = camera.directionWC;
-      height = camera.positionCartographic.height;
-      minimumHeight = 0.0;
-      maximumHeight = centerCartographic.height * 2.0;
-    } else {
-      const positionLocal = Matrix4.multiplyByPoint(transformLocal, camera.positionWC, scratchPosition);
-      up = Cartesian3.UNIT_Z;
-      direction = Matrix4.multiplyByPointAsVector(transformLocal, camera.directionWC, scratchDirection);
-      direction = Cartesian3.normalize(direction, direction);
-      height = positionLocal.z;
-
-      if (tileBoundingVolume instanceof TileOrientedBoundingBox) {
-        const boxHeight = root._header.boundingVolume.box[11];
-        minimumHeight = centerLocal.z - boxHeight;
-        maximumHeight = centerLocal.z + boxHeight;
-      } else if (tileBoundingVolume instanceof TileBoundingSphere) {
-        const radius = boundingVolume.radius;
-        minimumHeight = centerLocal.z - radius;
-        maximumHeight = centerLocal.z + radius;
-      }
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTiles3DScreenSpaceError = exports.getDynamicScreenSpaceError = exports.fog = exports.calculateDynamicScreenSpaceError = void 0;
+// TODO - Dynamic screen space error provides an optimization when looking at
+// tilesets from above
+/* eslint-disable */
+// @ts-nocheck
+const core_1 = require("@math.gl/core");
+const scratchPositionNormal = new core_1.Vector3();
+const scratchCartographic = new core_1.Vector3();
+const scratchMatrix = new core_1.Matrix4();
+const scratchCenter = new core_1.Vector3();
+const scratchPosition = new core_1.Vector3();
+const scratchDirection = new core_1.Vector3();
+// eslint-disable-next-line max-statements, complexity
+function calculateDynamicScreenSpaceError(root, { camera, mapProjection }, options = {}) {
+    const { dynamicScreenSpaceErrorHeightFalloff = 0.25, dynamicScreenSpaceErrorDensity = 0.00278 } = options;
+    let up;
+    let direction;
+    let height;
+    let minimumHeight;
+    let maximumHeight;
+    const tileBoundingVolume = root.contentBoundingVolume;
+    if (tileBoundingVolume instanceof TileBoundingRegion) {
+        up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
+        direction = camera.directionWC;
+        height = camera.positionCartographic.height;
+        minimumHeight = tileBoundingVolume.minimumHeight;
+        maximumHeight = tileBoundingVolume.maximumHeight;
     }
-  }
-
-  const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;
-  const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;
-  const heightFar = maximumHeight;
-  const t = clamp((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);
-  const dot = Math.abs(Cartesian3.dot(direction, up));
-  let horizonFactor = 1.0 - dot;
-  horizonFactor = horizonFactor * (1.0 - t);
-  return dynamicScreenSpaceErrorDensity * horizonFactor;
+    else {
+        // Transform camera position and direction into the local coordinate system of the tileset
+        const transformLocal = core_1.Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);
+        const ellipsoid = mapProjection.ellipsoid;
+        const boundingVolume = tileBoundingVolume.boundingVolume;
+        const centerLocal = core_1.Matrix4.multiplyByPoint(transformLocal, boundingVolume.center, scratchCenter);
+        if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {
+            // The tileset is defined in WGS84. Approximate the minimum and maximum height.
+            const centerCartographic = Cartographic.fromCartesian(centerLocal, ellipsoid, scratchCartographic);
+            up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
+            direction = camera.directionWC;
+            height = camera.positionCartographic.height;
+            minimumHeight = 0.0;
+            maximumHeight = centerCartographic.height * 2.0;
+        }
+        else {
+            // The tileset is defined in local coordinates (z-up)
+            const positionLocal = core_1.Matrix4.multiplyByPoint(transformLocal, camera.positionWC, scratchPosition);
+            up = Cartesian3.UNIT_Z;
+            direction = core_1.Matrix4.multiplyByPointAsVector(transformLocal, camera.directionWC, scratchDirection);
+            direction = Cartesian3.normalize(direction, direction);
+            height = positionLocal.z;
+            if (tileBoundingVolume instanceof TileOrientedBoundingBox) {
+                // Assuming z-up, the last component stores the half-height of the box
+                const boxHeight = root._header.boundingVolume.box[11];
+                minimumHeight = centerLocal.z - boxHeight;
+                maximumHeight = centerLocal.z + boxHeight;
+            }
+            else if (tileBoundingVolume instanceof TileBoundingSphere) {
+                const radius = boundingVolume.radius;
+                minimumHeight = centerLocal.z - radius;
+                maximumHeight = centerLocal.z + radius;
+            }
+        }
+    }
+    // The range where the density starts to lessen. Start at the quarter height of the tileset.
+    const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;
+    const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;
+    const heightFar = maximumHeight;
+    const t = (0, core_1.clamp)((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);
+    // Increase density as the camera tilts towards the horizon
+    const dot = Math.abs(Cartesian3.dot(direction, up));
+    let horizonFactor = 1.0 - dot;
+    // Weaken the horizon factor as the camera height increases, implying the camera is further away from the tileset.
+    // The goal is to increase density for the "street view", not when viewing the tileset from a distance.
+    horizonFactor = horizonFactor * (1.0 - t);
+    return dynamicScreenSpaceErrorDensity * horizonFactor;
 }
-export function fog(distanceToCamera, density) {
-  const scalar = distanceToCamera * density;
-  return 1.0 - Math.exp(-(scalar * scalar));
+exports.calculateDynamicScreenSpaceError = calculateDynamicScreenSpaceError;
+function fog(distanceToCamera, density) {
+    const scalar = distanceToCamera * density;
+    return 1.0 - Math.exp(-(scalar * scalar));
 }
-export function getDynamicScreenSpaceError(tileset, distanceToCamera) {
-  if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {
-    const density = tileset.dynamicScreenSpaceErrorComputedDensity;
-    const factor = tileset.dynamicScreenSpaceErrorFactor;
-    const dynamicError = fog(distanceToCamera, density) * factor;
-    return dynamicError;
-  }
-
-  return 0;
+exports.fog = fog;
+function getDynamicScreenSpaceError(tileset, distanceToCamera) {
+    if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {
+        const density = tileset.dynamicScreenSpaceErrorComputedDensity;
+        const factor = tileset.dynamicScreenSpaceErrorFactor;
+        // TODO: Refined screen space error that minimizes tiles in non-first-person
+        const dynamicError = fog(distanceToCamera, density) * factor;
+        return dynamicError;
+    }
+    return 0;
 }
-export function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
-  const tileset = tile.tileset;
-  const parentLodMetricValue = tile.parent && tile.parent.lodMetricValue || tile.lodMetricValue;
-  const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
-
-  if (lodMetricValue === 0.0) {
-    return 0.0;
-  }
-
-  const distance = Math.max(tile._distanceToCamera, 1e-7);
-  const {
-    height,
-    sseDenominator
-  } = frameState;
-  const {
-    viewDistanceScale
-  } = tileset.options;
-  let error = lodMetricValue * height * (viewDistanceScale || 1.0) / (distance * sseDenominator);
-  error -= getDynamicScreenSpaceError(tileset, distance);
-  return error;
+exports.getDynamicScreenSpaceError = getDynamicScreenSpaceError;
+function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
+    const tileset = tile.tileset;
+    const parentLodMetricValue = (tile.parent && tile.parent.lodMetricValue) || tile.lodMetricValue;
+    const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
+    // Leaf tiles do not have any error so save the computation
+    if (lodMetricValue === 0.0) {
+        return 0.0;
+    }
+    // TODO: Orthographic Frustum needs special treatment?
+    // this._getOrthograhicScreenSpaceError();
+    // Avoid divide by zero when viewer is inside the tile
+    const distance = Math.max(tile._distanceToCamera, 1e-7);
+    const { height, sseDenominator } = frameState;
+    const { viewDistanceScale } = tileset.options;
+    let error = (lodMetricValue * height * (viewDistanceScale || 1.0)) / (distance * sseDenominator);
+    error -= getDynamicScreenSpaceError(tileset, distance);
+    return error;
 }
-//# sourceMappingURL=tiles-3d-lod.js.map
+exports.getTiles3DScreenSpaceError = getTiles3DScreenSpaceError;

package/dist/tileset/helpers/transform-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function calculateTransformProps(tileHeader: any, tile: any): void;
+//# sourceMappingURL=transform-utils.d.ts.map

package/dist/tileset/helpers/transform-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-utils.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/transform-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,uBAAuB,CAAC,UAAU,KAAA,EAAE,IAAI,KAAA,QA4DvD"}

package/dist/tileset/helpers/transform-utils.js

@@ -1,55 +1,52 @@
-import { Ellipsoid } from '@math.gl/geospatial';
-import { Matrix4, Vector3 } from '@math.gl/core';
-import { assert } from '@loaders.gl/loader-utils';
-export function calculateTransformProps(tileHeader, tile) {
-  assert(tileHeader);
-  assert(tile);
-  const {
-    rtcCenter,
-    gltfUpAxis
-  } = tile;
-  const {
-    computedTransform,
-    boundingVolume: {
-      center
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTransformProps = void 0;
+const geospatial_1 = require("@math.gl/geospatial");
+const core_1 = require("@math.gl/core");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+function calculateTransformProps(tileHeader, tile) {
+    (0, loader_utils_1.assert)(tileHeader);
+    (0, loader_utils_1.assert)(tile);
+    const { rtcCenter, gltfUpAxis } = tile;
+    const { computedTransform, boundingVolume: { center } } = tileHeader;
+    let modelMatrix = new core_1.Matrix4(computedTransform);
+    // Translate if appropriate
+    if (rtcCenter) {
+        modelMatrix.translate(rtcCenter);
+    }
+    // glTF models need to be rotated from Y to Z up
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
+    switch (gltfUpAxis) {
+        case 'Z':
+            break;
+        case 'Y':
+            const rotationY = new core_1.Matrix4().rotateX(Math.PI / 2);
+            modelMatrix = modelMatrix.multiplyRight(rotationY);
+            break;
+        case 'X':
+            const rotationX = new core_1.Matrix4().rotateY(-Math.PI / 2);
+            modelMatrix = modelMatrix.multiplyRight(rotationX);
+            break;
+        default:
+            break;
+    }
+    // Scale/offset positions if normalized integers
+    if (tile.isQuantized) {
+        modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
+    }
+    // Option 1: Cartesian matrix and origin
+    const cartesianOrigin = new core_1.Vector3(center);
+    tile.cartesianModelMatrix = modelMatrix;
+    tile.cartesianOrigin = cartesianOrigin;
+    // Option 2: Cartographic matrix and origin
+    const cartographicOrigin = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new core_1.Vector3());
+    const fromFixedFrameMatrix = geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
+    const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
+    tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
+    tile.cartographicOrigin = cartographicOrigin;
+    // Deprecated, drop
+    if (!tile.coordinateSystem) {
+        tile.modelMatrix = tile.cartographicModelMatrix;
     }
-  } = tileHeader;
-  let modelMatrix = new Matrix4(computedTransform);
-
-  if (rtcCenter) {
-    modelMatrix.translate(rtcCenter);
-  }
-
-  switch (gltfUpAxis) {
-    case 'Z':
-      break;
-
-    case 'Y':
-      const rotationY = new Matrix4().rotateX(Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationY);
-      break;
-
-    case 'X':
-      const rotationX = new Matrix4().rotateY(-Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationX);
-      break;
-
-    default:
-      break;
-  }
-
-  if (tile.isQuantized) {
-    modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
-  }
-
-  const cartesianOrigin = new Vector3(center);
-  tile.cartesianModelMatrix = modelMatrix;
-  tile.cartesianOrigin = cartesianOrigin;
-  const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new Vector3());
-  const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
-  const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
-  tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
-  tile.cartographicOrigin = cartographicOrigin;
-  tile.modelMatrix = tile.cartographicModelMatrix;
 }
-//# sourceMappingURL=transform-utils.js.map
+exports.calculateTransformProps = calculateTransformProps;

package/dist/tileset/helpers/zoom.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calculate appropriate zoom value for a particular boundingVolume
+ * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume
+ * @returns {number} - zoom value
+ */
+export declare function getZoomFromBoundingVolume(boundingVolume: any): number;
+//# sourceMappingURL=zoom.d.ts.map

package/dist/tileset/helpers/zoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoom.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/zoom.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,cAAc,KAAA,UAoBvD"}

package/dist/tileset/helpers/zoom.js

@@ -1,36 +1,42 @@
-import { Vector3 } from '@math.gl/core';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZoomFromBoundingVolume = void 0;
+const core_1 = require("@math.gl/core");
 const WGS84_RADIUS_X = 6378137.0;
 const WGS84_RADIUS_Y = 6378137.0;
 const WGS84_RADIUS_Z = 6356752.3142451793;
-const scratchVector = new Vector3();
-export function getZoomFromBoundingVolume(boundingVolume) {
-  const {
-    halfAxes,
-    radius,
-    width,
-    height
-  } = boundingVolume;
-
-  if (halfAxes) {
-    const obbSize = getObbSize(halfAxes);
-    return Math.log2(WGS84_RADIUS_Z / obbSize);
-  } else if (radius) {
-    return Math.log2(WGS84_RADIUS_Z / radius);
-  } else if (height && width) {
-    const zoomX = Math.log2(WGS84_RADIUS_X / width);
-    const zoomY = Math.log2(WGS84_RADIUS_Y / height);
-    return (zoomX + zoomY) / 2;
-  }
-
-  return 1;
+const scratchVector = new core_1.Vector3();
+/**
+ * Calculate appropriate zoom value for a particular boundingVolume
+ * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume
+ * @returns {number} - zoom value
+ */
+function getZoomFromBoundingVolume(boundingVolume) {
+    const { halfAxes, radius, width, height } = boundingVolume;
+    if (halfAxes) {
+        // OrientedBoundingBox
+        const obbSize = getObbSize(halfAxes);
+        // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm
+        return Math.log2(WGS84_RADIUS_Z / obbSize);
+    }
+    else if (radius) {
+        // BoundingSphere
+        return Math.log2(WGS84_RADIUS_Z / radius);
+    }
+    else if (height && width) {
+        // BoundingRectangle
+        const zoomX = Math.log2(WGS84_RADIUS_X / width);
+        const zoomY = Math.log2(WGS84_RADIUS_Y / height);
+        return (zoomX + zoomY) / 2;
+    }
+    return 1;
 }
-
+exports.getZoomFromBoundingVolume = getZoomFromBoundingVolume;
 function getObbSize(halfAxes) {
-  halfAxes.getColumn(0, scratchVector);
-  const axeY = halfAxes.getColumn(1);
-  const axeZ = halfAxes.getColumn(2);
-  const farthestVertex = scratchVector.add(axeY).add(axeZ);
-  const size = farthestVertex.len();
-  return size;
+    halfAxes.getColumn(0, scratchVector);
+    const axeY = halfAxes.getColumn(1);
+    const axeZ = halfAxes.getColumn(2);
+    const farthestVertex = scratchVector.add(axeY).add(axeZ);
+    const size = farthestVertex.len();
+    return size;
 }
-//# sourceMappingURL=zoom.js.map

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

@@ -0,0 +1,174 @@
+import { Matrix4 } from '@math.gl/core';
+import { FrameState } from './helpers/frame-state';
+import type Tileset3D from './tileset-3d';
+/**
+ * @param tileset - Tileset3D instance
+ * @param header - tile header - JSON loaded from a dataset
+ * @param parentHeader - parent TileHeader instance
+ * @param extendedId - optional ID to separate copies of a tile for different viewports.
+ *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
+ */
+export declare type TileHeaderProps = {
+    tileset: Tileset3D;
+    header: Object;
+    parentHeader: TileHeader;
+    extendedId: string;
+};
+/**
+ * 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 default class TileHeader {
+    tileset: Tileset3D;
+    header: any;
+    id: string;
+    url: string;
+    parent: TileHeader;
+    refine: number;
+    type: string;
+    contentUrl: string;
+    lodMetricType: string;
+    lodMetricValue: number;
+    boundingVolume: any;
+    content: any;
+    contentState: any;
+    gpuMemoryUsageInBytes: number;
+    children: TileHeader[];
+    depth: number;
+    viewportIds: any[];
+    transform: Matrix4;
+    userData: {
+        [key: string]: any;
+    };
+    computedTransform: any;
+    hasEmptyContent: boolean;
+    hasTilesetContent: boolean;
+    traverser: object;
+    private _cacheNode;
+    private _frameNumber;
+    private _lodJudge;
+    private _expireDate;
+    private _expiredContent;
+    private _shouldRefine;
+    private _distanceToCamera;
+    private _centerZDepth;
+    private _screenSpaceError;
+    private _visibilityPlaneMask;
+    private _visible?;
+    private _inRequestVolume;
+    private _stackLength;
+    private _selectionDepth;
+    private _touchedFrame;
+    private _visitedFrame;
+    private _selectedFrame;
+    private _requestedFrame;
+    private _priority;
+    private _contentBoundingVolume;
+    private _viewerRequestVolume;
+    _initialTransform: Matrix4;
+    /**
+     * @constructs
+     * Create a TileHeader instance
+     * @param tileset - Tileset3D instance
+     * @param header - tile header - JSON loaded from a dataset
+     * @param parentHeader - parent TileHeader instance
+     * @param extendedId - optional ID to separate copies of a tile for different viewports.
+     *    const extendedId = `${tile.id}-${frameState.viewport.id}`;
+     */
+    constructor(tileset: Tileset3D, header: {
+        [key: string]: any;
+    }, parentHeader?: TileHeader, extendedId?: string);
+    destroy(): void;
+    isDestroyed(): boolean;
+    get selected(): boolean;
+    get isVisible(): boolean | undefined;
+    get isVisibleAndInRequestVolume(): boolean | undefined;
+    /** Returns true if tile is not an empty tile and not an external tileset */
+    get hasRenderContent(): boolean;
+    /** Returns true if tile has children */
+    get hasChildren(): any;
+    /**
+     * Determines if the tile's content is ready. This is automatically `true` for
+     * tiles with empty content.
+     */
+    get contentReady(): boolean;
+    /**
+     * 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(): boolean;
+    /** Returns true if tile has renderable content but it's unloaded */
+    get hasUnloadedContent(): boolean;
+    /**
+     * Determines if the tile's content has not be requested. `true` if tile's
+     * content has not be requested; otherwise, `false`.
+     */
+    get contentUnloaded(): boolean;
+    /**
+     * Determines if the tile's content is expired. `true` if tile's
+     * content is expired; otherwise, `false`.
+     */
+    get contentExpired(): boolean;
+    get contentFailed(): boolean;
+    /** Get the tile's screen space error. */
+    getScreenSpaceError(frameState: any, useParentLodMetric: any): number;
+    _getPriority(): number;
+    /**
+     *  Requests the tile's content.
+     * The request may not be made if the Request Scheduler can't prioritize it.
+     */
+    loadContent(): Promise<boolean>;
+    unloadContent(): boolean;
+    /**
+     * 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: any, viewportIds: any): void;
+    visibility(frameState: any, parentVisibilityPlaneMask: any): any;
+    contentVisibility(): boolean;
+    /**
+     * 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: FrameState): number;
+    /**
+     * Computes the tile's camera-space z-depth.
+     * @param frameState The frame state.
+     * @returns The distance, in meters.
+     */
+    cameraSpaceZDepth({ camera }: {
+        camera: any;
+    }): number;
+    /**
+     * 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: FrameState): boolean;
+    updateExpiration(): void;
+    get extras(): any;
+    _initializeLodMetric(header: any): void;
+    _initializeTransforms(tileHeader: any): void;
+    _initializeBoundingVolumes(tileHeader: any): void;
+    _initializeContent(tileHeader: any): void;
+    _initializeRenderingState(header: any): void;
+    _getRefine(refine: any): any;
+    _isTileset(): boolean;
+    _onContentLoaded(): void;
+    _updateBoundingVolume(header: any): void;
+    _updateTransform(parentTransform?: Matrix4): void;
+    _getLoaderSpecificOptions(loaderId: any): {
+        assetGltfUpAxis: any;
+    } | {
+        tile: any;
+        tileset: {
+            [key: string]: any;
+        };
+        isTileHeader: boolean;
+    };
+}
+//# sourceMappingURL=tile-3d.d.ts.map

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

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