@loaders.gl/tiles 4.0.0-alpha.4 → 4.0.0-alpha.6

package/src/tileset/tileset-3d.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 // 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
 
@@ -46,15 +48,19 @@ import {
   LoaderWithParser,
   LoaderOptions
 } from '@loaders.gl/loader-utils';
-import TilesetCache from './tileset-cache';
+import {TilesetCache} from './tileset-cache';
 import {calculateTransformProps} from './helpers/transform-utils';
-import {FrameState, getFrameState} from './helpers/frame-state';
-import {getZoomFromBoundingVolume} from './helpers/zoom';
-import Tile3D from './tile-3d';
-import Tileset3DTraverser from './traversers/tileset-3d-traverser';
-import TilesetTraverser from './traversers/tileset-traverser';
-import I3SetTraverser from './traversers/i3s-tileset-traverser';
+import {FrameState, getFrameState, limitSelectedTiles} from './helpers/frame-state';
+import {getZoomFromBoundingVolume, getZoomFromExtent, getZoomFromFullExtent} from './helpers/zoom';
+import {Tile3D} from './tile-3d';
 import {TILESET_TYPE} from '../constants';
+import {GeospatialViewport, Viewport} from '../types';
+
+import {TilesetTraverser} from './tileset-traverser';
+
+// TODO - these should be moved into their respective modules
+import {Tileset3DTraverser} from './format-3d-tiles/tileset-3d-traverser';
+import {I3STilesetTraverser} from './format-i3s/i3s-tileset-traverser';
 
 export type Tileset3DProps = {
   // loading
@@ -64,6 +70,8 @@ export type Tileset3DProps = {
   loadTiles?: boolean;
   basePath?: string;
   maximumMemoryUsage?: number;
+  maximumTilesSelected?: number;
+  debounceTime?: number;
 
   // Metadata
   description?: string;
@@ -93,6 +101,8 @@ type Props = {
   modelMatrix: Matrix4;
   throttleRequests: boolean;
   maximumMemoryUsage: number;
+  maximumTilesSelected: number;
+  debounceTime: number;
   onTileLoad: (tile: Tile3D) => any;
   onTileUnload: (tile: Tile3D) => any;
   onTileError: (tile: Tile3D, message: string, url: string) => any;
@@ -124,6 +134,10 @@ const DEFAULT_PROPS: Props = {
   maxRequests: 64,
 
   maximumMemoryUsage: 32,
+  /** Maximum number limit of tiles selected for show. 0 means no limit */
+  maximumTilesSelected: 0,
+  /** Delay time before the tileset traversal. It prevents traversal requests spam.*/
+  debounceTime: 0,
 
   /**
    * Callback. Indicates this a tile's content was loaded
@@ -149,7 +163,6 @@ const DEFAULT_PROPS: Props = {
   // View distance scale modifier
   viewDistanceScale: 1.0,
 
-  // TODO CESIUM
   // The maximum screen space error used to drive level of detail refinement.
   maximumScreenSpaceError: 8,
 
@@ -174,10 +187,10 @@ const TILES_LOADED = 'Tiles Loaded';
 const TILES_LOADING = 'Tiles Loading';
 const TILES_UNLOADED = 'Tiles Unloaded';
 const TILES_LOAD_FAILED = 'Failed Tile Loads';
-const POINTS_COUNT = 'Points';
+const POINTS_COUNT = 'Points/Vertices';
 const TILES_GPU_MEMORY = 'Tile Memory Use';
 
-export default class Tileset3D {
+export class Tileset3D {
   // props: Tileset3DProps;
   options: Props;
   loadOptions: {[key: string]: any};
@@ -204,9 +217,14 @@ export default class Tileset3D {
 
   stats: Stats;
 
+  /** flags that contain information about data types in nested tiles */
+  contentFormats = {draco: false, meshopt: false, dds: false, ktx2: false};
+
   traverseCounter: number;
   geometricError: number;
   selectedTiles: Tile3D[];
+  private updatePromise: Promise<number> | null = null;
+  tilesetInitializationPromise: Promise<void>;
 
   cartographicCenter: Vector3 | null;
   cartesianCenter: Vector3 | null;
@@ -235,7 +253,7 @@ export default class Tileset3D {
   private _pendingCount: any;
 
   // HOLD TRAVERSAL RESULTS
-  private lastUpdatedVieports: any[] | null;
+  private lastUpdatedVieports: Viewport[] | Viewport | null;
   private _requestedTiles: any;
   private _emptyTiles: any;
   private frameStateData: any;
@@ -324,7 +342,7 @@ export default class Tileset3D {
     this.credits = {};
     this.description = this.options.description || '';
 
-    this._initializeTileSet(json);
+    this.tilesetInitializationPromise = this._initializeTileSet(json);
   }
 
   /** Release resources */
@@ -335,7 +353,7 @@ export default class Tileset3D {
   /** Is the tileset loaded (update needs to have been called at least once) */
   isLoaded(): boolean {
     // Check that `_frameNumber !== 0` which means that update was called at least once
-    return this._pendingCount === 0 && this._frameNumber !== 0;
+    return this._pendingCount === 0 && this._frameNumber !== 0 && this._requestedTiles.length === 0;
   }
 
   get tiles(): object[] {
@@ -382,31 +400,68 @@ export default class Tileset3D {
   /**
    * Update visible tiles relying on a list of viewports
    * @param viewports - list of viewports
+   * @deprecated
+   */
+  update(viewports: Viewport[] | Viewport | null = null) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.tilesetInitializationPromise.then(() => {
+      if (!viewports && this.lastUpdatedVieports) {
+        viewports = this.lastUpdatedVieports;
+      } else {
+        this.lastUpdatedVieports = viewports;
+      }
+      if (viewports) {
+        this.doUpdate(viewports);
+      }
+    });
+  }
+
+  /**
+   * Update visible tiles relying on a list of viewports.
+   * Do it with debounce delay to prevent update spam
+   * @param viewports viewports
+   * @returns Promise of new frameNumber
+   */
+  async selectTiles(viewports: Viewport[] | Viewport | null = null): Promise<number> {
+    await this.tilesetInitializationPromise;
+    if (viewports) {
+      this.lastUpdatedVieports = viewports;
+    }
+    if (!this.updatePromise) {
+      this.updatePromise = new Promise<number>((resolve) => {
+        setTimeout(() => {
+          if (this.lastUpdatedVieports) {
+            this.doUpdate(this.lastUpdatedVieports);
+          }
+          resolve(this._frameNumber);
+          this.updatePromise = null;
+        }, this.options.debounceTime);
+      });
+    }
+    return this.updatePromise;
+  }
+
+  /**
+   * Update visible tiles relying on a list of viewports
+   * @param viewports viewports
    */
   // eslint-disable-next-line max-statements, complexity
-  update(viewports: any[]): void {
+  private doUpdate(viewports: Viewport[] | Viewport): void {
     if ('loadTiles' in this.options && !this.options.loadTiles) {
       return;
     }
     if (this.traverseCounter > 0) {
       return;
     }
-    if (!viewports && this.lastUpdatedVieports) {
-      viewports = this.lastUpdatedVieports;
-    } else {
-      this.lastUpdatedVieports = viewports;
-    }
-    if (!(viewports instanceof Array)) {
-      viewports = [viewports];
-    }
+    const preparedViewports = viewports instanceof Array ? viewports : [viewports];
 
     this._cache.reset();
     this._frameNumber++;
-    this.traverseCounter = viewports.length;
+    this.traverseCounter = preparedViewports.length;
     const viewportsToTraverse: string[] = [];
     // First loop to decrement traverseCounter
-    for (const viewport of viewports) {
-      const id = viewport.id as string;
+    for (const viewport of preparedViewports) {
+      const id = viewport.id;
       if (this._needTraverse(id)) {
         viewportsToTraverse.push(id);
       } else {
@@ -415,8 +470,8 @@ export default class Tileset3D {
     }
 
     // Second loop to traverse
-    for (const viewport of viewports) {
-      const id = viewport.id as string;
+    for (const viewport of preparedViewports) {
+      const id = viewport.id;
       if (!this.roots[id]) {
         this.roots[id] = this._initializeTileHeaders(this.tileset, null);
       }
@@ -424,7 +479,7 @@ export default class Tileset3D {
       if (!viewportsToTraverse.includes(id)) {
         continue; // eslint-disable-line no-continue
       }
-      const frameState = getFrameState(viewport, this._frameNumber);
+      const frameState = getFrameState(viewport as GeospatialViewport, this._frameNumber);
       this._traverser.traverse(this.roots[id], frameState, this.options);
     }
   }
@@ -457,7 +512,16 @@ export default class Tileset3D {
     }
     const currentFrameStateData = this.frameStateData[id];
     const selectedTiles = Object.values(this._traverser.selectedTiles);
-    currentFrameStateData.selectedTiles = selectedTiles;
+    const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(
+      selectedTiles,
+      frameState,
+      this.options.maximumTilesSelected
+    );
+    currentFrameStateData.selectedTiles = filteredSelectedTiles;
+    for (const tile of unselectedTiles) {
+      tile.unselect();
+    }
+
     currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);
     currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);
 
@@ -531,6 +595,9 @@ export default class Tileset3D {
         tilesRenderable++;
         if (tile.content.pointCount) {
           pointsRenderable += tile.content.pointCount;
+        } else {
+          // Calculate vertices for non point cloud tiles.
+          pointsRenderable += tile.content.vertexCount;
         }
       }
     }
@@ -540,37 +607,92 @@ export default class Tileset3D {
     this.stats.get(POINTS_COUNT).count = pointsRenderable;
   }
 
-  _initializeTileSet(tilesetJson) {
+  async _initializeTileSet(tilesetJson) {
+    if (this.type === TILESET_TYPE.I3S) {
+      this.calculateViewPropsI3S();
+      tilesetJson.root = await tilesetJson.root;
+    }
     this.root = this._initializeTileHeaders(tilesetJson, null);
 
-    // TODO CESIUM Specific
     if (this.type === TILESET_TYPE.TILES3D) {
-      this._initializeCesiumTileset(tilesetJson);
+      this._initializeTiles3DTileset(tilesetJson);
+      this.calculateViewPropsTiles3D();
     }
 
     if (this.type === TILESET_TYPE.I3S) {
       this._initializeI3STileset();
     }
-    // Calculate cartographicCenter & zoom props to help apps center view on tileset
-    this._calculateViewProps();
   }
 
-  // Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.
-  _calculateViewProps() {
+  /**
+   * Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.
+   * These metrics help apps center view on tileset
+   * For I3S there is extent (<1.8 version) or fullExtent (>=1.8 version) to calculate view props
+   * @returns
+   */
+  private calculateViewPropsI3S() {
+    // for I3S 1.8 try to calculate with fullExtent
+    const fullExtent = this.tileset.fullExtent;
+    if (fullExtent) {
+      const {xmin, xmax, ymin, ymax, zmin, zmax} = fullExtent;
+      this.cartographicCenter = new Vector3(
+        xmin + (xmax - xmin) / 2,
+        ymin + (ymax - ymin) / 2,
+        zmin + (zmax - zmin) / 2
+      );
+      this.cartesianCenter = Ellipsoid.WGS84.cartographicToCartesian(
+        this.cartographicCenter,
+        new Vector3()
+      );
+      this.zoom = getZoomFromFullExtent(fullExtent, this.cartographicCenter, this.cartesianCenter);
+      return;
+    }
+    // for I3S 1.6-1.7 try to calculate with extent
+    const extent = this.tileset.store?.extent;
+    if (extent) {
+      const [xmin, ymin, xmax, ymax] = extent;
+      this.cartographicCenter = new Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
+      this.cartesianCenter = Ellipsoid.WGS84.cartographicToCartesian(
+        this.cartographicCenter,
+        new Vector3()
+      );
+      this.zoom = getZoomFromExtent(extent, this.cartographicCenter, this.cartesianCenter);
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.warn('Extent is not defined in the tileset header');
+    this.cartographicCenter = new Vector3();
+    this.zoom = 1;
+    return;
+  }
+
+  /**
+   * Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.
+   * These metrics help apps center view on tileset.
+   * For 3DTiles the root tile data is used to calculate view props.
+   * @returns
+   */
+  private calculateViewPropsTiles3D() {
     const root = this.root as Tile3D;
     assert(root);
     const {center} = root.boundingVolume;
     // TODO - handle all cases
     if (!center) {
-      // eslint-disable-next-line
+      // eslint-disable-next-line no-console
       console.warn('center was not pre-calculated for the root tile');
       this.cartographicCenter = new Vector3();
       this.zoom = 1;
       return;
     }
-    this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());
+
+    // cartographic coordinates are undefined at the center of the ellipsoid
+    if (center[0] !== 0 || center[1] !== 0 || center[2] !== 0) {
+      this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());
+    } else {
+      this.cartographicCenter = new Vector3(0, 0, -Ellipsoid.WGS84.radii[0]);
+    }
     this.cartesianCenter = center;
-    this.zoom = getZoomFromBoundingVolume(root.boundingVolume);
+    this.zoom = getZoomFromBoundingVolume(root.boundingVolume, this.cartographicCenter);
   }
 
   _initializeStats() {
@@ -582,7 +704,7 @@ export default class Tileset3D {
     this.stats.get(TILES_LOADED);
     this.stats.get(TILES_UNLOADED);
     this.stats.get(TILES_LOAD_FAILED);
-    this.stats.get(POINTS_COUNT, 'memory');
+    this.stats.get(POINTS_COUNT);
     this.stats.get(TILES_GPU_MEMORY, 'memory');
   }
 
@@ -600,7 +722,7 @@ export default class Tileset3D {
       rootTile.depth = parentTileHeader.depth + 1;
     }
 
-    // Cesium 3d tiles knows the hierarchy beforehand
+    // 3DTiles knows the hierarchy beforehand
     if (this.type === TILESET_TYPE.TILES3D) {
       const stack: Tile3D[] = [];
       stack.push(rootTile);
@@ -629,7 +751,7 @@ export default class Tileset3D {
         TraverserClass = Tileset3DTraverser;
         break;
       case TILESET_TYPE.I3S:
-        TraverserClass = I3SetTraverser;
+        TraverserClass = I3STilesetTraverser;
         break;
       default:
         TraverserClass = TilesetTraverser;
@@ -673,15 +795,55 @@ export default class Tileset3D {
       return;
     }
 
+    if (this.type === TILESET_TYPE.I3S) {
+      // We can't calculate tiles total in I3S in advance so we calculate it dynamically.
+      const nodesInNodePages = this.tileset?.nodePagesTile?.nodesInNodePages || 0;
+      this.stats.get(TILES_TOTAL).reset();
+      this.stats.get(TILES_TOTAL).addCount(nodesInNodePages);
+    }
+
     // add coordinateOrigin and modelMatrix to tile
     if (tile && tile.content) {
       calculateTransformProps(tile, tile.content);
     }
 
+    this.updateContentTypes(tile);
     this._addTileToCache(tile);
     this.options.onTileLoad(tile);
   }
 
+  /**
+   * Update information about data types in nested tiles
+   * @param tile instance of a nested Tile3D
+   */
+  private updateContentTypes(tile: Tile3D) {
+    if (this.type === TILESET_TYPE.I3S) {
+      if (tile.header.isDracoGeometry) {
+        this.contentFormats.draco = true;
+      }
+      switch (tile.header.textureFormat) {
+        case 'dds':
+          this.contentFormats.dds = true;
+          break;
+        case 'ktx2':
+          this.contentFormats.ktx2 = true;
+          break;
+        default:
+      }
+    } else if (this.type === TILESET_TYPE.TILES3D) {
+      const {extensionsRemoved = []} = tile.content?.gltf || {};
+      if (extensionsRemoved.includes('KHR_draco_mesh_compression')) {
+        this.contentFormats.draco = true;
+      }
+      if (extensionsRemoved.includes('EXT_meshopt_compression')) {
+        this.contentFormats.meshopt = true;
+      }
+      if (extensionsRemoved.includes('KHR_texture_basisu')) {
+        this.contentFormats.ktx2 = true;
+      }
+    }
+  }
+
   _onStartTileLoading() {
     this._pendingCount++;
     this.stats.get(TILES_LOADING).incrementCount();
@@ -759,7 +921,7 @@ export default class Tileset3D {
     tile.destroy();
   }
 
-  _initializeCesiumTileset(tilesetJson) {
+  _initializeTiles3DTileset(tilesetJson) {
     this.asset = tilesetJson.asset;
     if (!this.asset) {
       throw new Error('Tileset must have an asset property.');

package/src/tileset/tileset-cache.ts

@@ -1,7 +1,9 @@
+// loaders.gl, MIT license
+
 // 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 DoublyLinkedList from '../utils/doubly-linked-list';
+import {DoublyLinkedList} from '../utils/doubly-linked-list';
 
 function defined(x) {
   return x !== undefined && x !== null;
@@ -12,7 +14,7 @@ function defined(x) {
  *
  * @private
  */
-export default class TilesetCache {
+export class TilesetCache {
   private _list: DoublyLinkedList;
   private _sentinel: any;
   private _trimTiles: boolean;
@@ -80,7 +82,9 @@ export default class TilesetCache {
       node !== sentinel &&
       (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)
     ) {
+      // @ts-expect-error
       const tile = node.item;
+      // @ts-expect-error
       node = node.next;
       this.unloadTile(tileset, tile, unloadCallback);
     }

package/src/tileset/{traversers/tileset-traverser.ts → tileset-traverser.ts}

@@ -1,5 +1,6 @@
-import ManagedArray from '../../utils/managed-array';
-import {TILE_REFINEMENT} from '../../constants';
+import {ManagedArray} from '../utils/managed-array';
+import {TILE_REFINEMENT} from '../constants';
+import {FrameState} from './helpers/frame-state';
 
 export type TilesetTraverserProps = {
   loadSiblings?: boolean;
@@ -8,19 +9,20 @@ export type TilesetTraverserProps = {
   onTraversalEnd?: (frameState) => any;
   viewportTraversersMap?: {[key: string]: any};
   basePath?: string;
+  updateTransforms?: boolean;
 };
 
-export type Props = {
-  loadSiblings: boolean;
-  skipLevelOfDetail: boolean;
-  updateTransforms: boolean;
-  maximumScreenSpaceError: number;
-  onTraversalEnd: (frameState) => any;
-  viewportTraversersMap: {[key: string]: any};
-  basePath: string;
-};
-
-export const DEFAULT_PROPS: Props = {
+// export type Props = {
+//   loadSiblings: boolean;
+//   skipLevelOfDetail: boolean;
+//   updateTransforms: boolean;
+//   maximumScreenSpaceError: number;
+//   onTraversalEnd: (frameState) => any;
+//   viewportTraversersMap: {[key: string]: any};
+//   basePath: string;
+// };
+
+export const DEFAULT_PROPS: Required<TilesetTraverserProps> = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   maximumScreenSpaceError: 2,
@@ -30,18 +32,24 @@ export const DEFAULT_PROPS: Props = {
   basePath: ''
 };
 
-export default class TilesetTraverser {
-  options: Props;
+export class TilesetTraverser {
+  options: Required<TilesetTraverserProps>;
 
   root: any;
   requestedTiles: object;
   selectedTiles: object;
   emptyTiles: object;
 
+  protected lastUpdate: number = new Date().getTime();
+  protected readonly updateDebounceTime = 1000;
   protected _traversalStack: ManagedArray;
   protected _emptyTraversalStack: ManagedArray;
   protected _frameNumber: number | null;
 
+  protected traversalFinished(frameState: FrameState): boolean {
+    return true;
+  }
+
   // TODO nested props
   constructor(options: TilesetTraverserProps) {
     this.options = {...DEFAULT_PROPS, ...options};
@@ -96,7 +104,7 @@ export default class TilesetTraverser {
   // all other tiles are part of the skip traversal. The skip traversal allows for skipping levels of the tree
   // and rendering children and parent tiles simultaneously.
   /* eslint-disable-next-line complexity, max-statements */
-  executeTraversal(root, frameState) {
+  executeTraversal(root, frameState: FrameState) {
     // stack to store traversed tiles, only visible tiles should be added to stack
     // visible: visible in the current view frustum
     const stack = this._traversalStack;
@@ -156,7 +164,11 @@ export default class TilesetTraverser {
       tile._shouldRefine = shouldRefine && parentRefines;
     }
 
-    this.options.onTraversalEnd(frameState);
+    const newTime = new Date().getTime();
+    if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
+      this.lastUpdate = newTime;
+      this.options.onTraversalEnd(frameState);
+    }
   }
 
   updateChildTiles(tile, frameState) {

package/src/types.ts

@@ -0,0 +1,36 @@
+import {Vector3} from '@math.gl/core';
+
+export type BoundingRectangle = {
+  width: number;
+  height: number;
+};
+
+/** Deck.gl Viewport instance type.
+ * We can't import it from Deck.gl to avoid circular reference */
+export type Viewport = {
+  id: string;
+  cameraPosition: number[] | Vector3;
+  height: number;
+  width: number;
+  zoom: number;
+  distanceScales: {
+    unitsPerMeter: number[];
+    metersPerUnit: number[];
+  };
+  center: number[] | Vector3;
+  unprojectPosition: (position: number[] | Vector3) => [number, number, number];
+  project: (coorinates: number[] | Vector3) => number[];
+};
+
+/**
+ * Contain extra fields from WebMercatorViewport and FirstPersonViewport
+ */
+export type GeospatialViewport = Viewport & {
+  /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
+  cameraDirection: [number, number, number];
+  /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
+  cameraUp: [number, number, number];
+  longitude: number;
+  latitude: number;
+  bearing: number;
+};

package/src/utils/{doubly-linked-list-node.js → doubly-linked-list-node.ts}

@@ -1,12 +1,17 @@
+// loaders.gl, MIT license
+
 // 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
 
 /**
  * Doubly linked list node
- *
  * @private
  */
-export default class DoublyLinkedListNode {
+export class DoublyLinkedListNode {
+  item;
+  previous;
+  next;
+
   constructor(item, previous, next) {
     this.item = item;
     this.previous = previous;

package/src/utils/{doubly-linked-list.js → doubly-linked-list.ts}

@@ -1,19 +1,16 @@
 // 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 DoublyLinkedListNode from '../utils/doubly-linked-list-node';
+import {DoublyLinkedListNode} from './doubly-linked-list-node';
 
 /**
  * Doubly linked list
- *
  * @private
  */
-export default class DoublyLinkedList {
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this._length = 0;
-  }
+export class DoublyLinkedList {
+  head: DoublyLinkedListNode | null = null;
+  tail: DoublyLinkedListNode | null = null;
+  _length = 0;
 
   get length() {
     return this._length;

package/src/utils/{managed-array.js → managed-array.ts}

@@ -12,10 +12,13 @@ import {assert} from '@loaders.gl/loader-utils';
  *
  * @param {Number} [length=0] The initial length of the array.
  */
-export default class ManagedArray {
+export class ManagedArray {
+  _map = new Map();
+  _array: any[];
+  _length: number;
+
   constructor(length = 0) {
     this._array = new Array(length);
-    this._map = new Map();
     this._length = length;
   }
 

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/constants.ts"],"names":["TILE_CONTENT_STATE","UNLOADED","LOADING","PROCESSING","READY","EXPIRED","FAILED","TILE_REFINEMENT","ADD","REPLACE","TILE_TYPE","EMPTY","SCENEGRAPH","POINTCLOUD","MESH","TILESET_TYPE","I3S","TILES3D","LOD_METRIC_TYPE","GEOMETRIC_ERROR","MAX_SCREEN_THRESHOLD","TILE3D_OPTIMIZATION_HINT","NOT_COMPUTED","USE_OPTIMIZATION","SKIP_OPTIMIZATION"],"mappings":"AAAA,OAAO,MAAMA,kBAAkB,GAAG;AAChCC,EAAAA,QAAQ,EAAE,CADsB;AAEhCC,EAAAA,OAAO,EAAE,CAFuB;AAGhCC,EAAAA,UAAU,EAAE,CAHoB;AAIhCC,EAAAA,KAAK,EAAE,CAJyB;AAKhCC,EAAAA,OAAO,EAAE,CALuB;AAMhCC,EAAAA,MAAM,EAAE;AANwB,CAA3B;AASP,OAAO,MAAMC,eAAe,GAAG;AAC7BC,EAAAA,GAAG,EAAE,CADwB;AAE7BC,EAAAA,OAAO,EAAE;AAFoB,CAAxB;AAKP,OAAO,MAAMC,SAAS,GAAG;AACvBC,EAAAA,KAAK,EAAE,OADgB;AAEvBC,EAAAA,UAAU,EAAE,YAFW;AAGvBC,EAAAA,UAAU,EAAE,YAHW;AAIvBC,EAAAA,IAAI,EAAE;AAJiB,CAAlB;AAOP,OAAO,MAAMC,YAAY,GAAG;AAC1BC,EAAAA,GAAG,EAAE,KADqB;AAE1BC,EAAAA,OAAO,EAAE;AAFiB,CAArB;AAKP,OAAO,MAAMC,eAAe,GAAG;AAC7BC,EAAAA,eAAe,EAAE,gBADY;AAE7BC,EAAAA,oBAAoB,EAAE;AAFO,CAAxB;AAMP,OAAO,MAAMC,wBAAwB,GAAG;AACtCC,EAAAA,YAAY,EAAE,CAAC,CADuB;AAEtCC,EAAAA,gBAAgB,EAAE,CAFoB;AAGtCC,EAAAA,iBAAiB,EAAE;AAHmB,CAAjC","sourcesContent":["export const TILE_CONTENT_STATE = {\n  UNLOADED: 0, // Has never been requested\n  LOADING: 1, // Is waiting on a pending request\n  PROCESSING: 2, // Request received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.\n  READY: 3, // Ready to render.\n  EXPIRED: 4, // Is expired and will be unloaded once new content is loaded.\n  FAILED: 5 // Request failed.\n};\n\nexport const TILE_REFINEMENT = {\n  ADD: 1, // Render tile and, if screen space error exceeded, also refine to its children.\n  REPLACE: 2 // Render tile or, if screen space error exceeded, refine to its descendants instead.\n};\n\nexport const TILE_TYPE = {\n  EMPTY: 'empty',\n  SCENEGRAPH: 'scenegraph',\n  POINTCLOUD: 'pointcloud',\n  MESH: 'mesh'\n};\n\nexport const TILESET_TYPE = {\n  I3S: 'I3S',\n  TILES3D: 'TILES3D'\n};\n\nexport const LOD_METRIC_TYPE = {\n  GEOMETRIC_ERROR: 'geometricError',\n  MAX_SCREEN_THRESHOLD: 'maxScreenThreshold'\n};\n\n// Cesium 3D Tiles Specific\nexport const TILE3D_OPTIMIZATION_HINT = {\n  NOT_COMPUTED: -1,\n  USE_OPTIMIZATION: 1,\n  SKIP_OPTIMIZATION: 0\n};\n"],"file":"constants.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["default","Tileset3D","Tile3D","TilesetTraverser","TilesetCache","createBoundingVolume","calculateTransformProps","getFrameState","TILE_CONTENT_STATE","TILE_REFINEMENT","TILE_TYPE","TILESET_TYPE","LOD_METRIC_TYPE"],"mappings":"AACA,SAAQA,OAAO,IAAIC,SAAnB,QAAmC,sBAAnC;AACA,SAAQD,OAAO,IAAIE,MAAnB,QAAgC,mBAAhC;AAEA,SAAQF,OAAO,IAAIG,gBAAnB,QAA0C,wCAA1C;AACA,SAAQH,OAAO,IAAII,YAAnB,QAAsC,yBAAtC;AAEA,SAAQC,oBAAR,QAAmC,mCAAnC;AACA,SAAQC,uBAAR,QAAsC,mCAAtC;AAEA,SAAQC,aAAR,QAA4B,+BAA5B;AAEA,SACEC,kBADF,EAEEC,eAFF,EAGEC,SAHF,EAIEC,YAJF,EAKEC,eALF,QAMO,aANP","sourcesContent":["export type {Tileset3DProps} from './tileset/tileset-3d';\nexport {default as Tileset3D} from './tileset/tileset-3d';\nexport {default as Tile3D} from './tileset/tile-3d';\n\nexport {default as TilesetTraverser} from './tileset/traversers/tileset-traverser';\nexport {default as TilesetCache} from './tileset/tileset-cache';\n\nexport {createBoundingVolume} from './tileset/helpers/bounding-volume';\nexport {calculateTransformProps} from './tileset/helpers/transform-utils';\n\nexport {getFrameState} from './tileset/helpers/frame-state';\n\nexport {\n  TILE_CONTENT_STATE,\n  TILE_REFINEMENT,\n  TILE_TYPE,\n  TILESET_TYPE,\n  LOD_METRIC_TYPE\n} from './constants';\n"],"file":"index.js"}

package/dist/tileset/helpers/3d-tiles-options.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/3d-tiles-options.ts"],"names":["get3dTilesOptions","tileset","assetGltfUpAxis","asset","gltfUpAxis"],"mappings":"AAAA,OAAO,SAASA,iBAAT,CAA2BC,OAA3B,EAAoC;AACzC,SAAO;AACLC,IAAAA,eAAe,EAAGD,OAAO,CAACE,KAAR,IAAiBF,OAAO,CAACE,KAAR,CAAcC,UAAhC,IAA+C;AAD3D,GAAP;AAGD","sourcesContent":["export function get3dTilesOptions(tileset) {\n  return {\n    assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'\n  };\n}\n"],"file":"3d-tiles-options.js"}