@loaders.gl/tiles 4.0.0-alpha.5 → 4.0.0-alpha.7

package/src/tileset/tileset-cache.ts

@@ -1,18 +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
 
-import DoublyLinkedList from '../utils/doubly-linked-list';
-
-function defined(x) {
-  return x !== undefined && x !== null;
-}
+import type {Tileset3D} from './tileset-3d';
+import type {Tile3D} from './tile-3d';
+import {DoublyLinkedList} from '../utils/doubly-linked-list';
 
 /**
  * Stores tiles with content loaded.
- *
  * @private
  */
-export default class TilesetCache {
+export class TilesetCache {
   private _list: DoublyLinkedList;
   private _sentinel: any;
   private _trimTiles: boolean;
@@ -25,22 +24,26 @@ export default class TilesetCache {
     this._trimTiles = false;
   }
 
-  reset() {
+  reset(): void {
     // Move sentinel node to the tail so, at the start of the frame, all tiles
     // may be potentially replaced.  Tiles are moved to the right of the sentinel
     // when they are selected so they will not be replaced.
     this._list.splice(this._list.tail, this._sentinel);
   }
 
-  touch(tile) {
+  touch(tile: Tile3D): void {
     const node = tile._cacheNode;
-    if (defined(node)) {
+    if (node) {
       this._list.splice(this._sentinel, node);
     }
   }
 
-  add(tileset, tile, addCallback) {
-    if (!defined(tile._cacheNode)) {
+  add(
+    tileset: Tileset3D,
+    tile: Tile3D,
+    addCallback?: (tileset: Tileset3D, tile: Tile3D) => void
+  ): void {
+    if (!tile._cacheNode) {
       tile._cacheNode = this._list.add(tile);
 
       if (addCallback) {
@@ -49,20 +52,24 @@ export default class TilesetCache {
     }
   }
 
-  unloadTile(tileset, tile, unloadCallback?) {
+  unloadTile(
+    tileset: Tileset3D,
+    tile: Tile3D,
+    unloadCallback?: (tileset: Tileset3D, tile: Tile3D) => void
+  ): void {
     const node = tile._cacheNode;
-    if (!defined(node)) {
+    if (!node) {
       return;
     }
 
     this._list.remove(node);
-    tile._cacheNode = undefined;
+    tile._cacheNode = null;
     if (unloadCallback) {
       unloadCallback(tileset, tile);
     }
   }
 
-  unloadTiles(tileset, unloadCallback) {
+  unloadTiles(tileset, unloadCallback): void {
     const trimTiles = this._trimTiles;
     this._trimTiles = false;
 
@@ -88,7 +95,7 @@ export default class TilesetCache {
     }
   }
 
-  trim() {
+  trim(): void {
     this._trimTiles = true;
   }
 }

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

@@ -1,26 +1,21 @@
-import ManagedArray from '../../utils/managed-array';
-import {TILE_REFINEMENT} from '../../constants';
+// loaders.gl, MIT license
+
+import type {Tile3D} from './tile-3d';
+import {ManagedArray} from '../utils/managed-array';
+import {TILE_REFINEMENT} from '../constants';
+import {FrameState} from './helpers/frame-state';
 
 export type TilesetTraverserProps = {
   loadSiblings?: boolean;
   skipLevelOfDetail?: boolean;
+  updateTransforms?: boolean;
   maximumScreenSpaceError?: number;
   onTraversalEnd?: (frameState) => any;
-  viewportTraversersMap?: {[key: string]: any};
+  viewportTraversersMap?: Record<string, any>;
   basePath?: string;
 };
 
-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 const DEFAULT_PROPS: Required<TilesetTraverserProps> = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   maximumScreenSpaceError: 2,
@@ -30,39 +25,35 @@ export const DEFAULT_PROPS: Props = {
   basePath: ''
 };
 
-export default class TilesetTraverser {
-  options: Props;
-
-  root: any;
-  requestedTiles: object;
-  selectedTiles: object;
-  emptyTiles: object;
-
-  protected _traversalStack: ManagedArray;
-  protected _emptyTraversalStack: ManagedArray;
-  protected _frameNumber: number | null;
+export class TilesetTraverser {
+  options: Required<TilesetTraverserProps>;
+
+  // fulfill in traverse call
+  root: any = null;
+
+  // tiles should be rendered
+  selectedTiles: Record<string, Tile3D> = {};
+  // tiles should be loaded from server
+  requestedTiles: Record<string, Tile3D> = {};
+  // tiles does not have render content
+  emptyTiles: Record<string, Tile3D> = {};
+
+  protected lastUpdate: number = new Date().getTime();
+  protected readonly updateDebounceTime = 1000;
+  /** temporary storage to hold the traversed tiles during a traversal */
+  protected _traversalStack = new ManagedArray();
+  protected _emptyTraversalStack = new ManagedArray();
+  /** set in every traverse cycle */
+  protected _frameNumber: number | null = null;
+
+  // RESULT
+  protected traversalFinished(frameState: FrameState): boolean {
+    return true;
+  }
 
   // TODO nested props
   constructor(options: TilesetTraverserProps) {
     this.options = {...DEFAULT_PROPS, ...options};
-    // TRAVERSAL
-    // temporary storage to hold the traversed tiles during a traversal
-    this._traversalStack = new ManagedArray();
-    this._emptyTraversalStack = new ManagedArray();
-
-    // set in every traverse cycle
-    this._frameNumber = null;
-
-    // fulfill in traverse call
-    this.root = null;
-
-    // RESULT
-    // tiles should be rendered
-    this.selectedTiles = {};
-    // tiles should be loaded from server
-    this.requestedTiles = {};
-    // tiles does not have render content
-    this.emptyTiles = {};
   }
 
   // tiles should be visible
@@ -88,15 +79,17 @@ export default class TilesetTraverser {
     this._emptyTraversalStack.reset();
   }
 
-  // execute traverse
-  // Depth-first traversal that traverses all visible tiles and marks tiles for selection.
-  // If skipLevelOfDetail is off then a tile does not refine until all children are loaded.
-  // This is the traditional replacement refinement approach and is called the base traversal.
-  // Tiles that have a greater screen space error than the base screen space error are part of the base traversal,
-  // 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.
+  /**
+   * Execute traverse
+   * Depth-first traversal that traverses all visible tiles and marks tiles for selection.
+   * If skipLevelOfDetail is off then a tile does not refine until all children are loaded.
+   * This is the traditional replacement refinement approach and is called the base traversal.
+   * Tiles that have a greater screen space error than the base screen space error are part of the base traversal,
+   * 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): void {
     // 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,19 +149,22 @@ 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) {
+  updateChildTiles(tile: Tile3D, frameState: FrameState): void {
     const children = tile.children;
     for (const child of children) {
       this.updateTile(child, frameState);
     }
-    return true;
   }
 
   /* eslint-disable complexity, max-statements */
-  updateAndPushChildren(tile, frameState, stack, depth) {
+  updateAndPushChildren(tile: Tile3D, frameState: FrameState, stack, depth): boolean {
     const {loadSiblings, skipLevelOfDetail} = this.options;
 
     const children = tile.children;
@@ -223,12 +219,12 @@ export default class TilesetTraverser {
   }
   /* eslint-enable complexity, max-statements */
 
-  updateTile(tile, frameState) {
+  updateTile(tile: Tile3D, frameState: FrameState): void {
     this.updateTileVisibility(tile, frameState);
   }
 
   // tile to render in the browser
-  selectTile(tile, frameState) {
+  selectTile(tile: Tile3D, frameState: FrameState): void {
     if (this.shouldSelectTile(tile)) {
       // The tile can be selected right away and does not require traverseAndSelect
       tile._selectedFrame = frameState.frameNumber;
@@ -237,7 +233,7 @@ export default class TilesetTraverser {
   }
 
   // tile to load from server
-  loadTile(tile, frameState) {
+  loadTile(tile: Tile3D, frameState: FrameState): void {
     if (this.shouldLoadTile(tile)) {
       tile._requestedFrame = frameState.frameNumber;
       tile._priority = tile._getPriority();
@@ -246,7 +242,7 @@ export default class TilesetTraverser {
   }
 
   // cache tile
-  touchTile(tile, frameState) {
+  touchTile(tile: Tile3D, frameState: FrameState): void {
     tile.tileset._cache.touch(tile);
     tile._touchedFrame = frameState.frameNumber;
   }
@@ -254,7 +250,12 @@ export default class TilesetTraverser {
   // tile should be visible
   // tile should have children
   // tile LoD (level of detail) is not sufficient under current viewport
-  canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {
+  canTraverse(
+    tile: Tile3D,
+    frameState: FrameState,
+    useParentMetric: boolean = false,
+    ignoreVisibility: boolean = false
+  ): boolean {
     if (!tile.hasChildren) {
       return false;
     }
@@ -273,20 +274,20 @@ export default class TilesetTraverser {
     return this.shouldRefine(tile, frameState, useParentMetric);
   }
 
-  shouldLoadTile(tile) {
+  shouldLoadTile(tile: Tile3D): boolean {
     // if request tile is in current frame
     // and has unexpired render content
     return tile.hasUnloadedContent || tile.contentExpired;
   }
 
-  shouldSelectTile(tile) {
+  shouldSelectTile(tile: Tile3D): boolean {
     // if select tile is in current frame
     // and content available
     return tile.contentAvailable && !this.options.skipLevelOfDetail;
   }
 
-  // Decide if tile LoD (level of detail) is not sufficient under current viewport
-  shouldRefine(tile, frameState, useParentMetric) {
+  /** Decide if tile LoD (level of detail) is not sufficient under current viewport */
+  shouldRefine(tile: Tile3D, frameState: FrameState, useParentMetric: boolean = false): boolean {
     let screenSpaceError = tile._screenSpaceError;
     if (useParentMetric) {
       screenSpaceError = tile.getScreenSpaceError(frameState, true);
@@ -295,7 +296,7 @@ export default class TilesetTraverser {
     return screenSpaceError > this.options.maximumScreenSpaceError;
   }
 
-  updateTileVisibility(tile, frameState) {
+  updateTileVisibility(tile: Tile3D, frameState: FrameState): void {
     const viewportIds: string[] = [];
     if (this.options.viewportTraversersMap) {
       for (const key in this.options.viewportTraversersMap) {
@@ -312,14 +313,16 @@ export default class TilesetTraverser {
 
   // UTILITIES
 
-  compareDistanceToCamera(b, a) {
+  compareDistanceToCamera(b: Tile3D, a: Tile3D): number {
     return b._distanceToCamera - a._distanceToCamera;
   }
 
-  anyChildrenVisible(tile, frameState) {
+  anyChildrenVisible(tile: Tile3D, frameState: FrameState): boolean {
     let anyVisible = false;
     for (const child of tile.children) {
+      // @ts-expect-error
       child.updateVisibility(frameState);
+      // @ts-expect-error
       anyVisible = anyVisible || child.isVisibleAndInRequestVolume;
     }
     return anyVisible;
@@ -327,7 +330,7 @@ export default class TilesetTraverser {
 
   // Depth-first traversal that checks if all nearest descendants with content are loaded.
   // Ignores visibility.
-  executeEmptyTraversal(root, frameState) {
+  executeEmptyTraversal(root: Tile3D, frameState: FrameState): boolean {
     let allDescendantsLoaded = true;
     const stack = this._emptyTraversalStack;
 
@@ -365,7 +368,3 @@ export default class TilesetTraverser {
     return allDescendantsLoaded;
   }
 }
-
-// TODO
-// enable expiration
-// enable optimization hint

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.ts

@@ -1,12 +1,13 @@
+// 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;

package/src/utils/doubly-linked-list.ts

@@ -1,14 +1,13 @@
 // 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 {
+export class DoublyLinkedList {
   head: DoublyLinkedListNode | null = null;
   tail: DoublyLinkedListNode | null = null;
   _length = 0;

package/src/utils/managed-array.ts

@@ -12,7 +12,7 @@ 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;

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","getLodStatus","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;AACA,SAAQC,YAAR,QAA2B,2BAA3B;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';\nexport {getLodStatus} from './tileset/helpers/i3s-lod';\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"}

package/dist/tileset/helpers/bounding-volume.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/bounding-volume.ts"],"names":["Quaternion","Vector3","Matrix3","Matrix4","degrees","BoundingSphere","OrientedBoundingBox","Ellipsoid","assert","defined","x","undefined","scratchScale","scratchNorthWest","scratchSouthEast","createBoundingVolume","boundingVolumeHeader","transform","result","box","createBox","region","west","south","east","north","minHeight","maxHeight","northWest","WGS84","cartographicToCartesian","southEast","centerInCartesian","addVectors","multiplyScalar","radius","subVectors","len","createSphere","sphere","Error","center","origin","length","halfSize","slice","quaternion","fromArray","y","z","transformByQuaternion","scale","toArray","xAxis","transformAsVector","yAxis","zAxis","halfAxes","getScale","uniformScale","Math","max"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/* eslint-disable */\nimport {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';\nimport {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {assert} from '@loaders.gl/loader-utils';\n\n// const scratchProjectedBoundingSphere = new BoundingSphere();\n\nfunction defined(x) {\n  return x !== undefined && x !== null;\n}\n\n// const scratchMatrix = new Matrix3();\nconst scratchScale = new Vector3();\nconst scratchNorthWest = new Vector3();\nconst scratchSouthEast = new Vector3();\n// const scratchRectangle = new Rectangle();\n// const scratchOrientedBoundingBox = new OrientedBoundingBox();\n// const scratchTransform = new Matrix4();\n\n/**\n * Create a bounding volume from the tile's bounding volume header.\n * @param {Object} boundingVolumeHeader The tile's bounding volume header.\n * @param {Matrix4} transform The transform to apply to the bounding volume.\n * @param [result] The object onto which to store the result.\n * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.\n */\nexport function createBoundingVolume(boundingVolumeHeader, transform, result) {\n  assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');\n\n  // boundingVolume schema:\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json\n  if (boundingVolumeHeader.box) {\n    return createBox(boundingVolumeHeader.box, transform, result);\n  }\n  if (boundingVolumeHeader.region) {\n    // [west, south, east, north, minimum height, maximum height]\n    // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.\n    // Heights are in meters above (or below) the WGS 84 ellipsoid.\n    const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;\n\n    const northWest = Ellipsoid.WGS84.cartographicToCartesian(\n      [degrees(west), degrees(north), minHeight],\n      scratchNorthWest\n    );\n    const southEast = Ellipsoid.WGS84.cartographicToCartesian(\n      [degrees(east), degrees(south), maxHeight],\n      scratchSouthEast\n    );\n    const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);\n    const radius = new Vector3().subVectors(northWest, southEast).len() / 2.0;\n\n    // TODO improve region boundingVolume\n    // for now, create a sphere as the boundingVolume instead of box\n    return createSphere(\n      [centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius],\n      new Matrix4()\n    );\n  }\n\n  if (boundingVolumeHeader.sphere) {\n    return createSphere(boundingVolumeHeader.sphere, transform, result);\n  }\n\n  throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');\n}\n\nfunction createBox(box, transform, result) {\n  // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box\n  // 1. A half-axes based representation.\n  // box: An array of 12 numbers that define an oriented bounding box.\n  // The first three elements define the x, y, and z values for the center of the box.\n  // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.\n  // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.\n  // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.\n  // 2. A half-size-quaternion based representation.\n  // box: An array of 10 numbers that define an oriented bounding box.\n  // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.\n  // The next three elements (with indices 3, 4, and 5) define the halfSize.\n  // The last four elements (indices 6, 7, 8 and 10) define the quaternion.\n  const center = new Vector3(box[0], box[1], box[2]);\n  transform.transform(center, center);\n  let origin: number[] = [];\n  if (box.length === 10) {\n    const halfSize = box.slice(3, 6);\n    const quaternion = new Quaternion();\n    quaternion.fromArray(box, 6);\n    const x = new Vector3([1, 0, 0]);\n    const y = new Vector3([0, 1, 0]);\n    const z = new Vector3([0, 0, 1]);\n    x.transformByQuaternion(quaternion);\n    x.scale(halfSize[0]);\n    y.transformByQuaternion(quaternion);\n    y.scale(halfSize[1]);\n    z.transformByQuaternion(quaternion);\n    z.scale(halfSize[2]);\n    origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];\n  } else {\n    origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];\n  }\n  const xAxis = transform.transformAsVector(origin.slice(0, 3));\n  const yAxis = transform.transformAsVector(origin.slice(3, 6));\n  const zAxis = transform.transformAsVector(origin.slice(6, 9));\n  const halfAxes = new Matrix3([\n    xAxis[0],\n    xAxis[1],\n    xAxis[2],\n    yAxis[0],\n    yAxis[1],\n    yAxis[2],\n    zAxis[0],\n    zAxis[1],\n    zAxis[2]\n  ]);\n\n  if (defined(result)) {\n    result.center = center;\n    result.halfAxes = halfAxes;\n    return result;\n  }\n\n  return new OrientedBoundingBox(center, halfAxes);\n}\n\n/*\nfunction createBoxFromTransformedRegion(region, transform, initialTransform, result) {\n  const rectangle = Rectangle.unpack(region, 0, scratchRectangle);\n  const minimumHeight = region[4];\n  const maximumHeight = region[5];\n\n  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(\n    rectangle,\n    minimumHeight,\n    maximumHeight,\n    Ellipsoid.WGS84,\n    scratchOrientedBoundingBox\n  );\n  const center = orientedBoundingBox.center;\n  const halfAxes = orientedBoundingBox.halfAxes;\n\n  // A region bounding volume is not transformed by the transform in the tileset JSON,\n  // but may be transformed by additional transforms applied in Cesium.\n  // This is why the transform is calculated as the difference between the initial transform and the current transform.\n  transform = Matrix4.multiplyTransformation(\n    transform,\n    Matrix4.inverseTransformation(initialTransform, scratchTransform),\n    scratchTransform\n  );\n  center = Matrix4.multiplyByPoint(transform, center, center);\n  const rotationScale = Matrix4.getRotation(transform, scratchMatrix);\n  halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);\n\n  if (defined(result) && result instanceof TileOrientedBoundingBox) {\n    result.update(center, halfAxes);\n    return result;\n  }\n\n  return new TileOrientedBoundingBox(center, halfAxes);\n}\n\nfunction createRegion(region, transform, initialTransform, result) {\n  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {\n    return createBoxFromTransformedRegion(region, transform, initialTransform, result);\n  }\n\n  if (defined(result)) {\n    return result;\n  }\n\n  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);\n\n  return new TileBoundingRegion({\n    rectangle: rectangleRegion,\n    minimumHeight: region[4],\n    maximumHeight: region[5]\n  });\n}\n*/\n\nfunction createSphere(sphere, transform, result?) {\n  // Find the transformed center\n  const center = new Vector3(sphere[0], sphere[1], sphere[2]);\n  transform.transform(center, center);\n  const scale = transform.getScale(scratchScale);\n\n  const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);\n  const radius = sphere[3] * uniformScale;\n\n  if (defined(result)) {\n    result.center = center;\n    result.radius = radius;\n    return result;\n  }\n\n  return new BoundingSphere(center, radius);\n}\n"],"file":"bounding-volume.js"}

package/dist/tileset/helpers/frame-state.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/frame-state.ts"],"names":["Vector3","CullingVolume","Plane","Ellipsoid","scratchVector","scratchPosition","cullingVolume","getFrameState","viewport","frameNumber","cameraDirection","cameraUp","height","metersPerUnit","distanceScales","viewportCenterCartographic","unprojectPosition","center","viewportCenterCartesian","WGS84","cartographicToCartesian","enuToFixedTransform","eastNorthUpToFixedFrame","cameraPositionCartographic","cameraPosition","cameraPositionCartesian","cameraDirectionCartesian","transformAsVector","scale","normalize","cameraUpCartesian","commonSpacePlanesToWGS84","camera","position","direction","up","sseDenominator","frustumPlanes","getFrustumPlanes","i","dir","plane","distanceToCenter","normal","dot","copy","distance","add","cartographicPos","cartesianPos","planes","fromPointNormal","subtract"],"mappings":"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","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {CullingVolume, Plane} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\n\nexport type FrameState = {\n  camera: {\n    position: number[];\n    direction: number[];\n    up: number[];\n  };\n  viewport: {[key: string]: any};\n  height: number;\n  cullingVolume: CullingVolume;\n  frameNumber: number; // TODO: This can be the same between updates, what number is unique for between updates?\n  sseDenominator: number; // Assumes fovy = 60 degrees\n};\n\nconst scratchVector = new Vector3();\nconst scratchPosition = new Vector3();\nconst cullingVolume = new CullingVolume([\n  new Plane(),\n  new Plane(),\n  new Plane(),\n  new Plane(),\n  new Plane(),\n  new Plane()\n]);\n\n// Extracts a frame state appropriate for tile culling from a deck.gl viewport\n// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios\nexport function getFrameState(viewport, frameNumber: number): FrameState {\n  // Traverse and and request. Update _selectedTiles so that we know what to render.\n  const {cameraDirection, cameraUp, height} = viewport;\n  const {metersPerUnit} = viewport.distanceScales;\n\n  const viewportCenterCartographic = viewport.unprojectPosition(viewport.center);\n  // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.\n  // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?\n  const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n    viewportCenterCartographic,\n    new Vector3()\n  );\n  const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);\n\n  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n  const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n    cameraPositionCartographic,\n    new Vector3()\n  );\n\n  // These should still be normalized as the transform has scale 1 (goes from meters to meters)\n  const cameraDirectionCartesian = new Vector3(\n    // @ts-ignore\n    enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))\n  ).normalize();\n  const cameraUpCartesian = new Vector3(\n    // @ts-ignore\n    enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))\n  ).normalize();\n\n  commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);\n\n  // TODO: make a file/class for frameState and document what needs to be attached to this so that traversal can function\n  return {\n    camera: {\n      position: cameraPositionCartesian,\n      direction: cameraDirectionCartesian,\n      up: cameraUpCartesian\n    },\n    viewport,\n    height,\n    cullingVolume,\n    frameNumber, // TODO: This can be the same between updates, what number is unique for between updates?\n    sseDenominator: 1.15 // Assumes fovy = 60 degrees\n  };\n}\n\nfunction commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {\n  // Extract frustum planes based on current view.\n  const frustumPlanes = viewport.getFrustumPlanes();\n  let i = 0;\n  for (const dir in frustumPlanes) {\n    const plane = frustumPlanes[dir];\n    const distanceToCenter = plane.normal.dot(viewport.center);\n    scratchPosition\n      .copy(plane.normal)\n      .scale(plane.distance - distanceToCenter)\n      .add(viewport.center);\n    const cartographicPos = viewport.unprojectPosition(scratchPosition);\n\n    const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());\n\n    cullingVolume.planes[i++].fromPointNormal(\n      cartesianPos,\n      // Want the normal to point into the frustum since that's what culling expects\n      scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos)\n    );\n  }\n}\n"],"file":"frame-state.js"}

package/dist/tileset/helpers/i3s-lod.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/i3s-lod.ts"],"names":["Matrix4","Vector3","Ellipsoid","getLodStatus","tile","frameState","lodMetricValue","isNaN","screenSize","getProjectedRadius","header","children","originalViewport","viewport","ViewportClass","constructor","longitude","latitude","height","width","bearing","zoom","pitch","mbsLat","mbs","mbsLon","mbsZ","mbsR","mbsCenterCartesian","boundingVolume","center","cameraPositionCartographic","unprojectPosition","cameraPosition","cameraPositionCartesian","WGS84","cartographicToCartesian","toEye","subtract","normalize","enuToCartesianMatrix","eastNorthUpToFixedFrame","cartesianToEnuMatrix","invert","cameraPositionEnu","transform","projection","Math","sqrt","extraZ","extraVertexEnu","extraVertexCartesian","extraVectorCartesian","radiusVector","cross","scale","sphereMbsBorderVertexCartesian","add","sphereMbsBorderVertexCartographic","cartesianToCartographic","projectedOrigin","project","projectedMbsBorderVertex","projectedRadius","magnitude"],"mappings":"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","sourcesContent":["import {Matrix4, Vector3} from '@math.gl/core';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport Tile3D from '../tile-3d';\nimport {FrameState} from './frame-state';\n\n/**\n * For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children\n   as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.\n   In this sense a value of 0 means you should always load it's children,\n   or if it's a leaf node, you should always display it.\n * @param tile \n * @param frameState \n * @returns \n */\nexport function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT' | 'DRAW' {\n  if (tile.lodMetricValue === 0 || isNaN(tile.lodMetricValue)) {\n    return 'DIG';\n  }\n  const screenSize = 2 * getProjectedRadius(tile, frameState);\n  if (screenSize < 2) {\n    return 'OUT';\n  }\n  if (!tile.header.children || screenSize <= tile.lodMetricValue) {\n    return 'DRAW';\n  } else if (tile.header.children) {\n    return 'DIG';\n  }\n  return 'OUT';\n}\n\n/**\n * Calculate size of MBS radius projected on the screen plane\n * @param tile\n * @param frameState\n * @returns\n */\n// eslint-disable-next-line max-statements\nexport function getProjectedRadius(tile: Tile3D, frameState: FrameState): number {\n  const originalViewport = frameState.viewport;\n  const ViewportClass = originalViewport.constructor;\n  const {longitude, latitude, height, width, bearing, zoom} = originalViewport;\n  // @ts-ignore\n  const viewport = new ViewportClass({longitude, latitude, height, width, bearing, zoom, pitch: 0});\n  const mbsLat = tile.header.mbs[1];\n  const mbsLon = tile.header.mbs[0];\n  const mbsZ = tile.header.mbs[2];\n  const mbsR = tile.header.mbs[3];\n  const mbsCenterCartesian = [...tile.boundingVolume.center];\n  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n  const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n    cameraPositionCartographic,\n    new Vector3()\n  );\n\n  // ---------------------------\n  // Calculate mbs border vertex\n  // ---------------------------\n  const toEye = new Vector3(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();\n  // Add extra vector to form plane\n  const enuToCartesianMatrix = new Matrix4();\n  Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);\n  const cartesianToEnuMatrix = new Matrix4(enuToCartesianMatrix).invert();\n  const cameraPositionEnu = new Vector3(cameraPositionCartesian).transform(cartesianToEnuMatrix);\n  // Mean Proportionals in Right Triangles - Altitude rule\n  // https://mathbitsnotebook.com/Geometry/RightTriangles/RTmeanRight.html\n  const projection = Math.sqrt(\n    cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]\n  );\n  const extraZ = (projection * projection) / cameraPositionEnu[2];\n  const extraVertexEnu = new Vector3([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);\n  const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);\n  const extraVectorCartesian = new Vector3(extraVertexCartesian)\n    .subtract(mbsCenterCartesian)\n    .normalize();\n  // We need radius vector orthogonal to toEye vector\n  const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);\n  const sphereMbsBorderVertexCartesian = new Vector3(mbsCenterCartesian).add(radiusVector);\n  const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(\n    sphereMbsBorderVertexCartesian\n  );\n  // ---------------------------\n\n  // Project center vertex and border vertex and calculate projected radius of MBS\n  const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);\n  const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);\n  const projectedRadius = new Vector3(projectedOrigin)\n    .subtract(projectedMbsBorderVertex)\n    .magnitude();\n  return projectedRadius;\n}\n"],"file":"i3s-lod.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/transform-utils.ts"],"names":["Ellipsoid","Matrix4","Vector3","assert","calculateTransformProps","tileHeader","tile","rtcCenter","gltfUpAxis","computedTransform","boundingVolume","center","modelMatrix","translate","rotationY","rotateX","Math","PI","multiplyRight","rotationX","rotateY","isQuantized","quantizedVolumeOffset","scale","quantizedVolumeScale","cartesianOrigin","cartesianModelMatrix","cartographicOrigin","WGS84","cartesianToCartographic","fromFixedFrameMatrix","eastNorthUpToFixedFrame","toFixedFrameMatrix","invert","cartographicModelMatrix","coordinateSystem"],"mappings":"AAAA,SAAQA,SAAR,QAAwB,qBAAxB;AACA,SAAQC,OAAR,EAAiBC,OAAjB,QAA+B,eAA/B;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAEA,OAAO,SAASC,uBAAT,CAAiCC,UAAjC,EAA6CC,IAA7C,EAAmD;AACxDH,EAAAA,MAAM,CAACE,UAAD,CAAN;AACAF,EAAAA,MAAM,CAACG,IAAD,CAAN;AAEA,QAAM;AAACC,IAAAA,SAAD;AAAYC,IAAAA;AAAZ,MAA0BF,IAAhC;AACA,QAAM;AACJG,IAAAA,iBADI;AAEJC,IAAAA,cAAc,EAAE;AAACC,MAAAA;AAAD;AAFZ,MAGFN,UAHJ;AAKA,MAAIO,WAAW,GAAG,IAAIX,OAAJ,CAAYQ,iBAAZ,CAAlB;;AAGA,MAAIF,SAAJ,EAAe;AACbK,IAAAA,WAAW,CAACC,SAAZ,CAAsBN,SAAtB;AACD;;AAID,UAAQC,UAAR;AACE,SAAK,GAAL;AACE;;AACF,SAAK,GAAL;AACE,YAAMM,SAAS,GAAG,IAAIb,OAAJ,GAAcc,OAAd,CAAsBC,IAAI,CAACC,EAAL,GAAU,CAAhC,CAAlB;AACAL,MAAAA,WAAW,GAAGA,WAAW,CAACM,aAAZ,CAA0BJ,SAA1B,CAAd;AACA;;AACF,SAAK,GAAL;AACE,YAAMK,SAAS,GAAG,IAAIlB,OAAJ,GAAcmB,OAAd,CAAsB,CAACJ,IAAI,CAACC,EAAN,GAAW,CAAjC,CAAlB;AACAL,MAAAA,WAAW,GAAGA,WAAW,CAACM,aAAZ,CAA0BC,SAA1B,CAAd;AACA;;AACF;AACE;AAZJ;;AAgBA,MAAIb,IAAI,CAACe,WAAT,EAAsB;AACpBT,IAAAA,WAAW,CAACC,SAAZ,CAAsBP,IAAI,CAACgB,qBAA3B,EAAkDC,KAAlD,CAAwDjB,IAAI,CAACkB,oBAA7D;AACD;;AAGD,QAAMC,eAAe,GAAG,IAAIvB,OAAJ,CAAYS,MAAZ,CAAxB;AAEAL,EAAAA,IAAI,CAACoB,oBAAL,GAA4Bd,WAA5B;AACAN,EAAAA,IAAI,CAACmB,eAAL,GAAuBA,eAAvB;AAGA,QAAME,kBAAkB,GAAG3B,SAAS,CAAC4B,KAAV,CAAgBC,uBAAhB,CACzBJ,eADyB,EAEzB,IAAIvB,OAAJ,EAFyB,CAA3B;AAIA,QAAM4B,oBAAoB,GAAG9B,SAAS,CAAC4B,KAAV,CAAgBG,uBAAhB,CAAwCN,eAAxC,CAA7B;AACA,QAAMO,kBAAkB,GAAGF,oBAAoB,CAACG,MAArB,EAA3B;AAEA3B,EAAAA,IAAI,CAAC4B,uBAAL,GAA+BF,kBAAkB,CAACd,aAAnB,CAAiCN,WAAjC,CAA/B;AACAN,EAAAA,IAAI,CAACqB,kBAAL,GAA0BA,kBAA1B;;AAGA,MAAI,CAACrB,IAAI,CAAC6B,gBAAV,EAA4B;AAC1B7B,IAAAA,IAAI,CAACM,WAAL,GAAmBN,IAAI,CAAC4B,uBAAxB;AACD;AACF","sourcesContent":["import {Ellipsoid} from '@math.gl/geospatial';\nimport {Matrix4, Vector3} from '@math.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function calculateTransformProps(tileHeader, tile) {\n  assert(tileHeader);\n  assert(tile);\n\n  const {rtcCenter, gltfUpAxis} = tile;\n  const {\n    computedTransform,\n    boundingVolume: {center}\n  } = tileHeader;\n\n  let modelMatrix = new Matrix4(computedTransform);\n\n  // Translate if appropriate\n  if (rtcCenter) {\n    modelMatrix.translate(rtcCenter);\n  }\n\n  // glTF models need to be rotated from Y to Z up\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up\n  switch (gltfUpAxis) {\n    case 'Z':\n      break;\n    case 'Y':\n      const rotationY = new Matrix4().rotateX(Math.PI / 2);\n      modelMatrix = modelMatrix.multiplyRight(rotationY);\n      break;\n    case 'X':\n      const rotationX = new Matrix4().rotateY(-Math.PI / 2);\n      modelMatrix = modelMatrix.multiplyRight(rotationX);\n      break;\n    default:\n      break;\n  }\n\n  // Scale/offset positions if normalized integers\n  if (tile.isQuantized) {\n    modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);\n  }\n\n  // Option 1: Cartesian matrix and origin\n  const cartesianOrigin = new Vector3(center);\n\n  tile.cartesianModelMatrix = modelMatrix;\n  tile.cartesianOrigin = cartesianOrigin;\n\n  // Option 2: Cartographic matrix and origin\n  const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(\n    cartesianOrigin,\n    new Vector3()\n  );\n  const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);\n  const toFixedFrameMatrix = fromFixedFrameMatrix.invert();\n\n  tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);\n  tile.cartographicOrigin = cartographicOrigin;\n\n  // Deprecated, drop\n  if (!tile.coordinateSystem) {\n    tile.modelMatrix = tile.cartographicModelMatrix;\n  }\n}\n"],"file":"transform-utils.js"}

package/dist/tileset/helpers/zoom.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/tileset/helpers/zoom.ts"],"names":["Vector3","WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z","scratchVector","getZoomFromBoundingVolume","boundingVolume","halfAxes","radius","width","height","obbSize","getObbSize","Math","log2","zoomX","zoomY","getColumn","axeY","axeZ","farthestVertex","add","size","len"],"mappings":"AAAA,SAAQA,OAAR,QAAsB,eAAtB;AAEA,MAAMC,cAAc,GAAG,SAAvB;AACA,MAAMC,cAAc,GAAG,SAAvB;AACA,MAAMC,cAAc,GAAG,kBAAvB;AAEA,MAAMC,aAAa,GAAG,IAAIJ,OAAJ,EAAtB;AAOA,OAAO,SAASK,yBAAT,CAAmCC,cAAnC,EAAmD;AACxD,QAAM;AAACC,IAAAA,QAAD;AAAWC,IAAAA,MAAX;AAAmBC,IAAAA,KAAnB;AAA0BC,IAAAA;AAA1B,MAAoCJ,cAA1C;;AAEA,MAAIC,QAAJ,EAAc;AAEZ,UAAMI,OAAO,GAAGC,UAAU,CAACL,QAAD,CAA1B;AAEA,WAAOM,IAAI,CAACC,IAAL,CAAUX,cAAc,GAAGQ,OAA3B,CAAP;AACD,GALD,MAKO,IAAIH,MAAJ,EAAY;AAEjB,WAAOK,IAAI,CAACC,IAAL,CAAUX,cAAc,GAAGK,MAA3B,CAAP;AACD,GAHM,MAGA,IAAIE,MAAM,IAAID,KAAd,EAAqB;AAE1B,UAAMM,KAAK,GAAGF,IAAI,CAACC,IAAL,CAAUb,cAAc,GAAGQ,KAA3B,CAAd;AACA,UAAMO,KAAK,GAAGH,IAAI,CAACC,IAAL,CAAUZ,cAAc,GAAGQ,MAA3B,CAAd;AAEA,WAAO,CAACK,KAAK,GAAGC,KAAT,IAAkB,CAAzB;AACD;;AAED,SAAO,CAAP;AACD;;AAED,SAASJ,UAAT,CAAoBL,QAApB,EAA8B;AAC5BA,EAAAA,QAAQ,CAACU,SAAT,CAAmB,CAAnB,EAAsBb,aAAtB;AACA,QAAMc,IAAI,GAAGX,QAAQ,CAACU,SAAT,CAAmB,CAAnB,CAAb;AACA,QAAME,IAAI,GAAGZ,QAAQ,CAACU,SAAT,CAAmB,CAAnB,CAAb;AACA,QAAMG,cAAc,GAAGhB,aAAa,CAACiB,GAAd,CAAkBH,IAAlB,EAAwBG,GAAxB,CAA4BF,IAA5B,CAAvB;AACA,QAAMG,IAAI,GAAGF,cAAc,CAACG,GAAf,EAAb;AACA,SAAOD,IAAP;AACD","sourcesContent":["import {Vector3} from '@math.gl/core';\n\nconst WGS84_RADIUS_X = 6378137.0;\nconst WGS84_RADIUS_Y = 6378137.0;\nconst WGS84_RADIUS_Z = 6356752.3142451793;\n\nconst scratchVector = new Vector3();\n\n/**\n * Calculate appropriate zoom value for a particular boundingVolume\n * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume\n * @returns {number} - zoom value\n */\nexport function getZoomFromBoundingVolume(boundingVolume) {\n  const {halfAxes, radius, width, height} = boundingVolume;\n\n  if (halfAxes) {\n    // OrientedBoundingBox\n    const obbSize = getObbSize(halfAxes);\n    // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm\n    return Math.log2(WGS84_RADIUS_Z / obbSize);\n  } else if (radius) {\n    // BoundingSphere\n    return Math.log2(WGS84_RADIUS_Z / radius);\n  } else if (height && width) {\n    // BoundingRectangle\n    const zoomX = Math.log2(WGS84_RADIUS_X / width);\n    const zoomY = Math.log2(WGS84_RADIUS_Y / height);\n\n    return (zoomX + zoomY) / 2;\n  }\n\n  return 1;\n}\n\nfunction getObbSize(halfAxes) {\n  halfAxes.getColumn(0, scratchVector);\n  const axeY = halfAxes.getColumn(1);\n  const axeZ = halfAxes.getColumn(2);\n  const farthestVertex = scratchVector.add(axeY).add(axeZ);\n  const size = farthestVertex.len();\n  return size;\n}\n"],"file":"zoom.js"}