@loaders.gl/tiles 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/tileset/tileset-cache.js

@@ -0,0 +1,79 @@
+"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
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const doubly_linked_list_1 = __importDefault(require("../utils/doubly-linked-list"));
+function defined(x) {
+    return x !== undefined && x !== null;
+}
+/**
+ * Stores tiles with content loaded.
+ *
+ * @private
+ */
+class TilesetCache {
+    constructor() {
+        // [head, sentinel) -> tiles that weren't selected this frame and may be removed from the cache
+        // (sentinel, tail] -> tiles that were selected this frame
+        this._list = new doubly_linked_list_1.default();
+        this._sentinel = this._list.add('sentinel');
+        this._trimTiles = false;
+    }
+    reset() {
+        // 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) {
+        const node = tile._cacheNode;
+        if (defined(node)) {
+            this._list.splice(this._sentinel, node);
+        }
+    }
+    add(tileset, tile, addCallback) {
+        if (!defined(tile._cacheNode)) {
+            tile._cacheNode = this._list.add(tile);
+            if (addCallback) {
+                addCallback(tileset, tile);
+            }
+        }
+    }
+    unloadTile(tileset, tile, unloadCallback) {
+        const node = tile._cacheNode;
+        if (!defined(node)) {
+            return;
+        }
+        this._list.remove(node);
+        tile._cacheNode = undefined;
+        if (unloadCallback) {
+            unloadCallback(tileset, tile);
+        }
+    }
+    unloadTiles(tileset, unloadCallback) {
+        const trimTiles = this._trimTiles;
+        this._trimTiles = false;
+        const list = this._list;
+        const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
+        // Traverse the list only to the sentinel since tiles/nodes to the
+        // right of the sentinel were used this frame.
+        // The sub-list to the left of the sentinel is ordered from LRU to MRU.
+        const sentinel = this._sentinel;
+        let node = list.head;
+        while (node !== sentinel &&
+            (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
+            // @ts-expect-error
+            const tile = node.item;
+            // @ts-expect-error
+            node = node.next;
+            this.unloadTile(tileset, tile, unloadCallback);
+        }
+    }
+    trim() {
+        this._trimTiles = true;
+    }
+}
+exports.default = TilesetCache;

package/dist/tileset/traversers/i3s-tile-manager.d.ts

@@ -0,0 +1,8 @@
+export default class I3STileManager {
+    private _statusMap;
+    constructor();
+    add(request: any, key: any, callback: any, frameState: any): void;
+    update(key: any, frameState: any): void;
+    find(key: any): any;
+}
+//# sourceMappingURL=i3s-tile-manager.d.ts.map

package/dist/tileset/traversers/i3s-tile-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-tile-manager.d.ts","sourceRoot":"","sources":["../../../src/tileset/traversers/i3s-tile-manager.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,UAAU,CAAS;;IAM3B,GAAG,CAAC,OAAO,KAAA,EAAE,GAAG,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA;IAetC,MAAM,CAAC,GAAG,KAAA,EAAE,UAAU,KAAA;IAMtB,IAAI,CAAC,GAAG,KAAA;CAGT"}

package/dist/tileset/traversers/i3s-tile-manager.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const STATUS = {
+    REQUESTED: 'REQUESTED',
+    COMPLETED: 'COMPLETED',
+    ERROR: 'ERROR'
+};
+// A helper class to manage tile metadata fetching
+class I3STileManager {
+    constructor() {
+        this._statusMap = {};
+    }
+    add(request, key, callback, frameState) {
+        if (!this._statusMap[key]) {
+            this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
+            request()
+                .then((data) => {
+                this._statusMap[key].status = STATUS.COMPLETED;
+                this._statusMap[key].callback(data, frameState);
+            })
+                .catch((error) => {
+                this._statusMap[key].status = STATUS.ERROR;
+                callback(error);
+            });
+        }
+    }
+    update(key, frameState) {
+        if (this._statusMap[key]) {
+            this._statusMap[key].frameState = frameState;
+        }
+    }
+    find(key) {
+        return this._statusMap[key];
+    }
+}
+exports.default = I3STileManager;

package/dist/tileset/traversers/i3s-tileset-traverser.d.ts

@@ -0,0 +1,18 @@
+import TilesetTraverser from './tileset-traverser';
+export default class I3STilesetTraverser extends TilesetTraverser {
+    private _tileManager;
+    constructor(options: any);
+    shouldRefine(tile: any, frameState: any): boolean;
+    updateChildTiles(tile: any, frameState: any): boolean;
+    _loadTile(nodeId: any, tileset: any): Promise<any>;
+    /**
+     * The callback to init TileHeader instance after loading the tile JSON
+     * @param {Object} header - the tile JSON from a dataset
+     * @param {TileHeader} tile - the parent TileHeader instance
+     * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.
+     *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
+     * @return {void}
+     */
+    _onTileLoad(header: any, tile: any, extendedId: any): void;
+}
+//# sourceMappingURL=i3s-tileset-traverser.d.ts.map

package/dist/tileset/traversers/i3s-tileset-traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-tileset-traverser.d.ts","sourceRoot":"","sources":["../../../src/tileset/traversers/i3s-tileset-traverser.ts"],"names":[],"mappings":"AACA,OAAO,gBAAgB,MAAM,qBAAqB,CAAC;AAMnD,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,gBAAgB;IAC/D,OAAO,CAAC,YAAY,CAAiB;gBAEzB,OAAO,KAAA;IAKnB,YAAY,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAK7B,gBAAgB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,GAAG,OAAO;IAoCrC,SAAS,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA;IAgB/B;;;;;;;OAOG;IACH,WAAW,CAAC,MAAM,KAAA,EAAE,IAAI,KAAA,EAAE,UAAU,KAAA;CAYrC"}

package/dist/tileset/traversers/i3s-tileset-traverser.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const tileset_traverser_1 = __importDefault(require("./tileset-traverser"));
+const i3s_lod_1 = require("../helpers/i3s-lod");
+const tile_3d_1 = __importDefault(require("../tile-3d"));
+const i3s_tile_manager_1 = __importDefault(require("./i3s-tile-manager"));
+class I3STilesetTraverser extends tileset_traverser_1.default {
+    constructor(options) {
+        super(options);
+        this._tileManager = new i3s_tile_manager_1.default();
+    }
+    shouldRefine(tile, frameState) {
+        tile._lodJudge = (0, i3s_lod_1.getLodStatus)(tile, frameState);
+        return tile._lodJudge === 'DIG';
+    }
+    updateChildTiles(tile, frameState) {
+        const children = tile.header.children || [];
+        // children which are already fetched and constructed as Tile3D instances
+        const childTiles = tile.children;
+        const tileset = tile.tileset;
+        for (const child of children) {
+            const extendedId = `${child.id}-${frameState.viewport.id}`;
+            // if child tile is not fetched
+            const childTile = childTiles && childTiles.find((t) => t.id === extendedId);
+            if (!childTile) {
+                let request = () => this._loadTile(child.id, tileset);
+                const cachedRequest = this._tileManager.find(extendedId);
+                if (!cachedRequest) {
+                    // eslint-disable-next-line max-depth
+                    if (tileset.tileset.nodePages) {
+                        request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);
+                    }
+                    this._tileManager.add(request, extendedId, (header) => this._onTileLoad(header, tile, extendedId), frameState);
+                }
+                else {
+                    // update frameNumber since it is still needed in current frame
+                    this._tileManager.update(extendedId, frameState);
+                }
+            }
+            else if (childTile) {
+                // if child tile is fetched and available
+                this.updateTile(childTile, frameState);
+            }
+        }
+        return false;
+    }
+    async _loadTile(nodeId, tileset) {
+        const { loader } = tileset;
+        const nodeUrl = tileset.getTileUrl(`${tileset.url}/nodes/${nodeId}`);
+        // load metadata
+        const options = {
+            ...tileset.loadOptions,
+            i3s: {
+                ...tileset.loadOptions.i3s,
+                isTileHeader: true,
+                loadContent: false
+            }
+        };
+        return await (0, core_1.load)(nodeUrl, loader, options);
+    }
+    /**
+     * The callback to init TileHeader instance after loading the tile JSON
+     * @param {Object} header - the tile JSON from a dataset
+     * @param {TileHeader} tile - the parent TileHeader instance
+     * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.
+     *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
+     * @return {void}
+     */
+    _onTileLoad(header, tile, extendedId) {
+        // after child tile is fetched
+        const childTile = new tile_3d_1.default(tile.tileset, header, tile, extendedId);
+        tile.children.push(childTile);
+        const frameState = this._tileManager.find(childTile.id).frameState;
+        this.updateTile(childTile, frameState);
+        // after tile fetched, resume traversal if still in current update/traversal frame
+        if (this._frameNumber === frameState.frameNumber) {
+            this.executeTraversal(childTile, frameState);
+        }
+    }
+}
+exports.default = I3STilesetTraverser;

package/dist/tileset/traversers/tileset-3d-traverser.d.ts

@@ -0,0 +1,7 @@
+import TilesetTraverser from './tileset-traverser';
+export default class Tileset3DTraverser extends TilesetTraverser {
+    compareDistanceToCamera(a: any, b: any): number;
+    updateTileVisibility(tile: any, frameState: any): void;
+    meetsScreenSpaceErrorEarly(tile: any, frameState: any): boolean;
+}
+//# sourceMappingURL=tileset-3d-traverser.d.ts.map

package/dist/tileset/traversers/tileset-3d-traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset-3d-traverser.d.ts","sourceRoot":"","sources":["../../../src/tileset/traversers/tileset-3d-traverser.ts"],"names":[],"mappings":"AAIA,OAAO,gBAAgB,MAAM,qBAAqB,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,gBAAgB;IAC9D,uBAAuB,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;IAO5B,oBAAoB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAmCrC,0BAA0B,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;CAS5C"}

package/dist/tileset/traversers/tileset-3d-traverser.js

@@ -0,0 +1,55 @@
+"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
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const tileset_traverser_1 = __importDefault(require("./tileset-traverser"));
+class Tileset3DTraverser extends tileset_traverser_1.default {
+    compareDistanceToCamera(a, b) {
+        // Sort by farthest child first since this is going on a stack
+        return b._distanceToCamera === 0 && a._distanceToCamera === 0
+            ? b._centerZDepth - a._centerZDepth
+            : b._distanceToCamera - a._distanceToCamera;
+    }
+    updateTileVisibility(tile, frameState) {
+        super.updateTileVisibility(tile, frameState);
+        //  Optimization - if none of the tile's children are visible then this tile isn't visible
+        if (!tile.isVisibleAndInRequestVolume) {
+            return;
+        }
+        const hasChildren = tile.children.length > 0;
+        if (tile.hasTilesetContent && hasChildren) {
+            // Use the root tile's visibility instead of this tile's visibility.
+            // The root tile may be culled by the children bounds optimization in which
+            // case this tile should also be culled.
+            const firstChild = tile.children[0];
+            this.updateTileVisibility(firstChild, frameState);
+            tile._visible = firstChild._visible;
+            return;
+        }
+        if (this.meetsScreenSpaceErrorEarly(tile, frameState)) {
+            tile._visible = false;
+            return;
+        }
+        const replace = tile.refine === constants_1.TILE_REFINEMENT.REPLACE;
+        const useOptimization = tile._optimChildrenWithinParent === constants_1.TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;
+        if (replace && useOptimization && hasChildren) {
+            if (!this.anyChildrenVisible(tile, frameState)) {
+                tile._visible = false;
+                return;
+            }
+        }
+    }
+    meetsScreenSpaceErrorEarly(tile, frameState) {
+        const { parent } = tile;
+        if (!parent || parent.hasTilesetContent || parent.refine !== constants_1.TILE_REFINEMENT.ADD) {
+            return false;
+        }
+        // Use parent's geometric error with child's box to see if the tile already meet the SSE
+        return !this.shouldRefine(tile, frameState, true);
+    }
+}
+exports.default = Tileset3DTraverser;

package/dist/tileset/traversers/tileset-traverser.d.ts

@@ -0,0 +1,52 @@
+import ManagedArray from '../../utils/managed-array';
+export declare type TilesetTraverserProps = {
+    loadSiblings?: boolean;
+    skipLevelOfDetail?: boolean;
+    maximumScreenSpaceError?: number;
+    onTraversalEnd?: (frameState: any) => any;
+    viewportTraversersMap?: {
+        [key: string]: any;
+    };
+    basePath?: string;
+};
+export declare type Props = {
+    loadSiblings: boolean;
+    skipLevelOfDetail: boolean;
+    updateTransforms: boolean;
+    maximumScreenSpaceError: number;
+    onTraversalEnd: (frameState: any) => any;
+    viewportTraversersMap: {
+        [key: string]: any;
+    };
+    basePath: string;
+};
+export declare const DEFAULT_PROPS: Props;
+export default class TilesetTraverser {
+    options: Props;
+    root: any;
+    requestedTiles: object;
+    selectedTiles: object;
+    emptyTiles: object;
+    protected _traversalStack: ManagedArray;
+    protected _emptyTraversalStack: ManagedArray;
+    protected _frameNumber: number | null;
+    constructor(options: TilesetTraverserProps);
+    traverse(root: any, frameState: any, options: any): void;
+    reset(): void;
+    executeTraversal(root: any, frameState: any): void;
+    updateChildTiles(tile: any, frameState: any): boolean;
+    updateAndPushChildren(tile: any, frameState: any, stack: any, depth: any): boolean;
+    updateTile(tile: any, frameState: any): void;
+    selectTile(tile: any, frameState: any): void;
+    loadTile(tile: any, frameState: any): void;
+    touchTile(tile: any, frameState: any): void;
+    canTraverse(tile: any, frameState: any, useParentMetric?: boolean, ignoreVisibility?: boolean): boolean;
+    shouldLoadTile(tile: any): any;
+    shouldSelectTile(tile: any): any;
+    shouldRefine(tile: any, frameState: any, useParentMetric: any): boolean;
+    updateTileVisibility(tile: any, frameState: any): void;
+    compareDistanceToCamera(b: any, a: any): number;
+    anyChildrenVisible(tile: any, frameState: any): boolean;
+    executeEmptyTraversal(root: any, frameState: any): boolean;
+}
+//# sourceMappingURL=tileset-traverser.d.ts.map

package/dist/tileset/traversers/tileset-traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileset-traverser.d.ts","sourceRoot":"","sources":["../../../src/tileset/traversers/tileset-traverser.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,2BAA2B,CAAC;AAGrD,oBAAY,qBAAqB,GAAG;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,CAAC,UAAU,KAAA,KAAK,GAAG,CAAC;IACrC,qBAAqB,CAAC,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,oBAAY,KAAK,GAAG;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,uBAAuB,EAAE,MAAM,CAAC;IAChC,cAAc,EAAE,CAAC,UAAU,KAAA,KAAK,GAAG,CAAC;IACpC,qBAAqB,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,KAQ3B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,OAAO,EAAE,KAAK,CAAC;IAEf,IAAI,EAAE,GAAG,CAAC;IACV,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,CAAC,eAAe,EAAE,YAAY,CAAC;IACxC,SAAS,CAAC,oBAAoB,EAAE,YAAY,CAAC;IAC7C,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;gBAG1B,OAAO,EAAE,qBAAqB;IAuB1C,QAAQ,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA;IAclC,KAAK;IAgBL,gBAAgB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IA+DjC,gBAAgB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IASjC,qBAAqB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,KAAK,KAAA,EAAE,KAAK,KAAA;IAuDpD,UAAU,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAK3B,UAAU,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAS3B,QAAQ,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IASzB,SAAS,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAQ1B,WAAW,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,eAAe,UAAQ,EAAE,gBAAgB,UAAQ;IAmB/E,cAAc,CAAC,IAAI,KAAA;IAMnB,gBAAgB,CAAC,IAAI,KAAA;IAOrB,YAAY,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,eAAe,KAAA;IAS9C,oBAAoB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAiBrC,uBAAuB,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;IAI5B,kBAAkB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;IAWnC,qBAAqB,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA;CAqCvC"}

package/dist/tileset/traversers/tileset-traverser.js

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROPS = void 0;
+const managed_array_1 = __importDefault(require("../../utils/managed-array"));
+const constants_1 = require("../../constants");
+exports.DEFAULT_PROPS = {
+    loadSiblings: false,
+    skipLevelOfDetail: false,
+    maximumScreenSpaceError: 2,
+    updateTransforms: true,
+    onTraversalEnd: () => { },
+    viewportTraversersMap: {},
+    basePath: ''
+};
+class TilesetTraverser {
+    // TODO nested props
+    constructor(options) {
+        this.options = { ...exports.DEFAULT_PROPS, ...options };
+        // TRAVERSAL
+        // temporary storage to hold the traversed tiles during a traversal
+        this._traversalStack = new managed_array_1.default();
+        this._emptyTraversalStack = new managed_array_1.default();
+        // 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
+    traverse(root, frameState, options) {
+        this.root = root; // for root screen space error
+        this.options = { ...this.options, ...options };
+        // reset result
+        this.reset();
+        // update tile (visibility and expiration)
+        this.updateTile(root, frameState);
+        this._frameNumber = frameState.frameNumber;
+        this.executeTraversal(root, frameState);
+    }
+    reset() {
+        this.requestedTiles = {};
+        this.selectedTiles = {};
+        this.emptyTiles = {};
+        this._traversalStack.reset();
+        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.
+    /* eslint-disable-next-line complexity, max-statements */
+    executeTraversal(root, 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;
+        root._selectionDepth = 1;
+        stack.push(root);
+        while (stack.length > 0) {
+            // 1. pop tile
+            const tile = stack.pop();
+            // 2. check if tile needs to be refine, needs refine if a tile's LoD is not sufficient and tile has available children (available content)
+            let shouldRefine = false;
+            if (this.canTraverse(tile, frameState)) {
+                this.updateChildTiles(tile, frameState);
+                shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
+            }
+            // 3. decide if should render (select) this tile
+            //   - tile does not have render content
+            //   - tile has render content and tile is `add` type (pointcloud)
+            //   - tile has render content and tile is `replace` type (photogrammetry) and can't refine any further
+            const parent = tile.parent;
+            const parentRefines = Boolean(!parent || parent._shouldRefine);
+            const stoppedRefining = !shouldRefine;
+            if (!tile.hasRenderContent) {
+                this.emptyTiles[tile.id] = tile;
+                this.loadTile(tile, frameState);
+                if (stoppedRefining) {
+                    this.selectTile(tile, frameState);
+                }
+                // additive tiles
+            }
+            else if (tile.refine === constants_1.TILE_REFINEMENT.ADD) {
+                // Additive tiles are always loaded and selected
+                this.loadTile(tile, frameState);
+                this.selectTile(tile, frameState);
+                // replace tiles
+            }
+            else if (tile.refine === constants_1.TILE_REFINEMENT.REPLACE) {
+                // Always load tiles in the base traversal
+                // Select tiles that can't refine further
+                this.loadTile(tile, frameState);
+                if (stoppedRefining) {
+                    this.selectTile(tile, frameState);
+                }
+            }
+            // 3. update cache, most recent touched tiles have higher priority to be fetched from server
+            this.touchTile(tile, frameState);
+            // 4. update tile refine prop and parent refinement status to trickle down to the descendants
+            tile._shouldRefine = shouldRefine && parentRefines;
+        }
+        this.options.onTraversalEnd(frameState);
+    }
+    updateChildTiles(tile, frameState) {
+        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) {
+        const { loadSiblings, skipLevelOfDetail } = this.options;
+        const children = tile.children;
+        // sort children tiles
+        children.sort(this.compareDistanceToCamera.bind(this));
+        // For traditional replacement refinement only refine if all children are loaded.
+        // Empty tiles are exempt since it looks better if children stream in as they are loaded to fill the empty space.
+        const checkRefines = tile.refine === constants_1.TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
+        let hasVisibleChild = false;
+        let refines = true;
+        for (const child of children) {
+            child._selectionDepth = depth;
+            if (child.isVisibleAndInRequestVolume) {
+                if (stack.find(child)) {
+                    stack.delete(child);
+                }
+                stack.push(child);
+                hasVisibleChild = true;
+            }
+            else if (checkRefines || loadSiblings) {
+                // Keep non-visible children loaded since they are still needed before the parent can refine.
+                // Or loadSiblings is true so always load tiles regardless of visibility.
+                this.loadTile(child, frameState);
+                this.touchTile(child, frameState);
+            }
+            if (checkRefines) {
+                let childRefines;
+                if (!child._inRequestVolume) {
+                    childRefines = false;
+                }
+                else if (!child.hasRenderContent) {
+                    childRefines = this.executeEmptyTraversal(child, frameState);
+                }
+                else {
+                    childRefines = child.contentAvailable;
+                }
+                refines = refines && childRefines;
+                if (!refines) {
+                    return false;
+                }
+            }
+        }
+        if (!hasVisibleChild) {
+            refines = false;
+        }
+        return refines;
+    }
+    /* eslint-enable complexity, max-statements */
+    updateTile(tile, frameState) {
+        this.updateTileVisibility(tile, frameState);
+    }
+    // tile to render in the browser
+    selectTile(tile, frameState) {
+        if (this.shouldSelectTile(tile)) {
+            // The tile can be selected right away and does not require traverseAndSelect
+            tile._selectedFrame = frameState.frameNumber;
+            this.selectedTiles[tile.id] = tile;
+        }
+    }
+    // tile to load from server
+    loadTile(tile, frameState) {
+        if (this.shouldLoadTile(tile)) {
+            tile._requestedFrame = frameState.frameNumber;
+            tile._priority = tile._getPriority();
+            this.requestedTiles[tile.id] = tile;
+        }
+    }
+    // cache tile
+    touchTile(tile, frameState) {
+        tile.tileset._cache.touch(tile);
+        tile._touchedFrame = frameState.frameNumber;
+    }
+    // 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) {
+        if (!tile.hasChildren) {
+            return false;
+        }
+        // cesium specific
+        if (tile.hasTilesetContent) {
+            // Traverse external this to visit its root tile
+            // Don't traverse if the subtree is expired because it will be destroyed
+            return !tile.contentExpired;
+        }
+        if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {
+            return false;
+        }
+        return this.shouldRefine(tile, frameState, useParentMetric);
+    }
+    shouldLoadTile(tile) {
+        // if request tile is in current frame
+        // and has unexpired render content
+        return tile.hasUnloadedContent || tile.contentExpired;
+    }
+    shouldSelectTile(tile) {
+        // 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) {
+        let screenSpaceError = tile._screenSpaceError;
+        if (useParentMetric) {
+            screenSpaceError = tile.getScreenSpaceError(frameState, true);
+        }
+        return screenSpaceError > this.options.maximumScreenSpaceError;
+    }
+    updateTileVisibility(tile, frameState) {
+        const viewportIds = [];
+        if (this.options.viewportTraversersMap) {
+            for (const key in this.options.viewportTraversersMap) {
+                const value = this.options.viewportTraversersMap[key];
+                if (value === frameState.viewport.id) {
+                    viewportIds.push(key);
+                }
+            }
+        }
+        else {
+            viewportIds.push(frameState.viewport.id);
+        }
+        tile.updateVisibility(frameState, viewportIds);
+    }
+    // UTILITIES
+    compareDistanceToCamera(b, a) {
+        return b._distanceToCamera - a._distanceToCamera;
+    }
+    anyChildrenVisible(tile, frameState) {
+        let anyVisible = false;
+        for (const child of tile.children) {
+            child.updateVisibility(frameState);
+            anyVisible = anyVisible || child.isVisibleAndInRequestVolume;
+        }
+        return anyVisible;
+    }
+    // Depth-first traversal that checks if all nearest descendants with content are loaded.
+    // Ignores visibility.
+    executeEmptyTraversal(root, frameState) {
+        let allDescendantsLoaded = true;
+        const stack = this._emptyTraversalStack;
+        stack.push(root);
+        while (stack.length > 0 && allDescendantsLoaded) {
+            const tile = stack.pop();
+            this.updateTile(tile, frameState);
+            if (!tile.isVisibleAndInRequestVolume) {
+                // Load tiles that aren't visible since they are still needed for the parent to refine
+                this.loadTile(tile, frameState);
+            }
+            this.touchTile(tile, frameState);
+            // Only traverse if the tile is empty - traversal stop at descendants with content
+            const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);
+            if (traverse) {
+                const children = tile.children;
+                for (const child of children) {
+                    // eslint-disable-next-line max-depth
+                    if (stack.find(child)) {
+                        stack.delete(child);
+                    }
+                    stack.push(child);
+                }
+            }
+            else if (!tile.contentAvailable) {
+                allDescendantsLoaded = false;
+            }
+        }
+        return allDescendantsLoaded;
+    }
+}
+exports.default = TilesetTraverser;
+// TODO
+// enable expiration
+// enable optimization hint

package/dist/utils/doubly-linked-list-node.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Doubly linked list node
+ *
+ * @private
+ */
+export default class DoublyLinkedListNode {
+    item: any;
+    previous: any;
+    next: any;
+    constructor(item: any, previous: any, next: any);
+}
+//# sourceMappingURL=doubly-linked-list-node.d.ts.map