@loaders.gl/tiles 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/tileset/tileset-cache.js

@@ -1,72 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TilesetCache = void 0;
-const doubly_linked_list_1 = require("../utils/doubly-linked-list");
-/**
- * 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.DoublyLinkedList();
-        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 (node) {
-            this._list.splice(this._sentinel, node);
-        }
-    }
-    add(tileset, tile, addCallback) {
-        if (!tile._cacheNode) {
-            tile._cacheNode = this._list.add(tile);
-            if (addCallback) {
-                addCallback(tileset, tile);
-            }
-        }
-    }
-    unloadTile(tileset, tile, unloadCallback) {
-        const node = tile._cacheNode;
-        if (!node) {
-            return;
-        }
-        this._list.remove(node);
-        tile._cacheNode = null;
-        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.TilesetCache = TilesetCache;

package/dist/tileset/tileset-traverser.js

@@ -1,300 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TilesetTraverser = exports.DEFAULT_PROPS = void 0;
-const managed_array_1 = 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 {
-    // RESULT
-    traversalFinished(frameState) {
-        return true;
-    }
-    // TODO nested props
-    constructor(options) {
-        // fulfill in traverse call
-        this.root = null;
-        // tiles should be rendered
-        this.selectedTiles = {};
-        // tiles should be loaded from server
-        this.requestedTiles = {};
-        // tiles does not have render content
-        this.emptyTiles = {};
-        this.lastUpdate = new Date().getTime();
-        this.updateDebounceTime = 1000;
-        /** temporary storage to hold the traversed tiles during a traversal */
-        this._traversalStack = new managed_array_1.ManagedArray();
-        this._emptyTraversalStack = new managed_array_1.ManagedArray();
-        /** set in every traverse cycle */
-        this._frameNumber = null;
-        this.options = { ...exports.DEFAULT_PROPS, ...options };
-    }
-    // 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;
-        }
-        const newTime = new Date().getTime();
-        if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
-            this.lastUpdate = newTime;
-            this.options.onTraversalEnd(frameState);
-        }
-    }
-    updateChildTiles(tile, frameState) {
-        const children = tile.children;
-        for (const child of children) {
-            this.updateTile(child, frameState);
-        }
-    }
-    /* 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 = false) {
-        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) {
-            // @ts-expect-error
-            child.updateVisibility(frameState);
-            // @ts-expect-error
-            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.TilesetTraverser = TilesetTraverser;

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/doubly-linked-list-node.js

@@ -1,18 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoublyLinkedListNode = void 0;
-// 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
- */
-class DoublyLinkedListNode {
-    constructor(item, previous, next) {
-        this.item = item;
-        this.previous = previous;
-        this.next = next;
-    }
-}
-exports.DoublyLinkedListNode = DoublyLinkedListNode;

package/dist/utils/doubly-linked-list.js

@@ -1,97 +0,0 @@
-"use strict";
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoublyLinkedList = void 0;
-const doubly_linked_list_node_1 = require("./doubly-linked-list-node");
-/**
- * Doubly linked list
- * @private
- */
-class DoublyLinkedList {
-    constructor() {
-        this.head = null;
-        this.tail = null;
-        this._length = 0;
-    }
-    get length() {
-        return this._length;
-    }
-    /**
-     * Adds the item to the end of the list
-     * @param {*} [item]
-     * @return {DoublyLinkedListNode}
-     */
-    add(item) {
-        const node = new doubly_linked_list_node_1.DoublyLinkedListNode(item, this.tail, null);
-        if (this.tail) {
-            this.tail.next = node;
-            this.tail = node;
-        }
-        else {
-            this.head = node;
-            this.tail = node;
-        }
-        ++this._length;
-        return node;
-    }
-    /**
-     * Removes the given node from the list
-     * @param {DoublyLinkedListNode} node
-     */
-    remove(node) {
-        if (!node) {
-            return;
-        }
-        if (node.previous && node.next) {
-            node.previous.next = node.next;
-            node.next.previous = node.previous;
-        }
-        else if (node.previous) {
-            // Remove last node
-            node.previous.next = null;
-            this.tail = node.previous;
-        }
-        else if (node.next) {
-            // Remove first node
-            node.next.previous = null;
-            this.head = node.next;
-        }
-        else {
-            // Remove last node in the linked list
-            this.head = null;
-            this.tail = null;
-        }
-        node.next = null;
-        node.previous = null;
-        --this._length;
-    }
-    /**
-     * Moves nextNode after node
-     * @param {DoublyLinkedListNode} node
-     * @param {DoublyLinkedListNode} nextNode
-     */
-    splice(node, nextNode) {
-        if (node === nextNode) {
-            return;
-        }
-        // Remove nextNode, then insert after node
-        this.remove(nextNode);
-        this._insert(node, nextNode);
-    }
-    _insert(node, nextNode) {
-        const oldNodeNext = node.next;
-        node.next = nextNode;
-        // nextNode is the new tail
-        if (this.tail === node) {
-            this.tail = nextNode;
-        }
-        else {
-            oldNodeNext.previous = nextNode;
-        }
-        nextNode.next = oldNodeNext;
-        nextNode.previous = node;
-        ++this._length;
-    }
-}
-exports.DoublyLinkedList = DoublyLinkedList;

package/dist/utils/managed-array.js

@@ -1,152 +0,0 @@
-"use strict";
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagedArray = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-/**
- * A wrapper around arrays so that the internal length of the array can be manually managed.
- *
- * @alias ManagedArray
- * @constructor
- * @private
- *
- * @param {Number} [length=0] The initial length of the array.
- */
-class ManagedArray {
-    constructor(length = 0) {
-        this._map = new Map();
-        this._array = new Array(length);
-        this._length = length;
-    }
-    /**
-     * Gets or sets the length of the array.
-     * If the set length is greater than the length of the internal array, the internal array is resized.
-     *
-     * @memberof ManagedArray.prototype
-     * @type Number
-     */
-    get length() {
-        return this._length;
-    }
-    set length(length) {
-        this._length = length;
-        if (length > this._array.length) {
-            this._array.length = length;
-        }
-    }
-    /**
-     * Gets the internal array.
-     *
-     * @memberof ManagedArray.prototype
-     * @type Array
-     * @readonly
-     */
-    get values() {
-        return this._array;
-    }
-    /**
-     * Gets the element at an index.
-     *
-     * @param {Number} index The index to get.
-     */
-    get(index) {
-        (0, loader_utils_1.assert)(index < this._array.length);
-        return this._array[index];
-    }
-    /**
-     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
-     *
-     * @param {Number} index The index to set.
-     * @param {*} element The element to set at index.
-     */
-    set(index, element) {
-        (0, loader_utils_1.assert)(index >= 0);
-        if (index >= this.length) {
-            this.length = index + 1;
-        }
-        if (this._map.has(this._array[index])) {
-            this._map.delete(this._array[index]);
-        }
-        this._array[index] = element;
-        this._map.set(element, index);
-    }
-    delete(element) {
-        const index = this._map.get(element);
-        if (index >= 0) {
-            this._array.splice(index, 1);
-            this._map.delete(element);
-            this.length--;
-        }
-    }
-    /**
-     * Returns the last element in the array without modifying the array.
-     *
-     * @returns {*} The last element in the array.
-     */
-    peek() {
-        return this._array[this._length - 1];
-    }
-    /**
-     * Push an element into the array.
-     *
-     * @param {*} element The element to push.
-     */
-    push(element) {
-        if (!this._map.has(element)) {
-            const index = this.length++;
-            this._array[index] = element;
-            this._map.set(element, index);
-        }
-    }
-    /**
-     * Pop an element from the array.
-     *
-     * @returns {*} The last element in the array.
-     */
-    pop() {
-        const element = this._array[--this.length];
-        this._map.delete(element);
-        return element;
-    }
-    /**
-     * Resize the internal array if length > _array.length.
-     *
-     * @param {Number} length The length.
-     */
-    reserve(length) {
-        (0, loader_utils_1.assert)(length >= 0);
-        if (length > this._array.length) {
-            this._array.length = length;
-        }
-    }
-    /**
-     * Resize the array.
-     *
-     * @param {Number} length The length.
-     */
-    resize(length) {
-        (0, loader_utils_1.assert)(length >= 0);
-        this.length = length;
-    }
-    /**
-     * Trim the internal array to the specified length. Defaults to the current length.
-     *
-     * @param {Number} [length] The length.
-     */
-    trim(length) {
-        if (length === null || length === undefined) {
-            length = this.length;
-        }
-        this._array.length = length;
-    }
-    reset() {
-        this._array = [];
-        this._map = new Map();
-        this._length = 0;
-    }
-    find(target) {
-        return this._map.has(target);
-    }
-}
-exports.ManagedArray = ManagedArray;