@deck.gl/geo-layers 9.0.0-beta.1 → 9.0.0-beta.11

package/dist/terrain-layer/terrain-layer.js

@@ -0,0 +1,233 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { CompositeLayer, log } from '@deck.gl/core';
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import { COORDINATE_SYSTEM } from '@deck.gl/core';
+import { TerrainWorkerLoader } from '@loaders.gl/terrain';
+import TileLayer from "../tile-layer/tile-layer.js";
+import { urlType, getURLFromTemplate } from "../tileset-2d/index.js";
+const DUMMY_DATA = [1];
+const defaultProps = {
+    ...TileLayer.defaultProps,
+    // Image url that encodes height data
+    elevationData: urlType,
+    // Image url to use as texture
+    texture: { ...urlType, optional: true },
+    // Martini error tolerance in meters, smaller number -> more detailed mesh
+    meshMaxError: { type: 'number', value: 4.0 },
+    // Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates
+    bounds: { type: 'array', value: null, optional: true, compare: true },
+    // Color to use if texture is unavailable
+    color: { type: 'color', value: [255, 255, 255] },
+    // Object to decode height data, from (r, g, b) to height in meters
+    elevationDecoder: {
+        type: 'object',
+        value: {
+            rScaler: 1,
+            gScaler: 0,
+            bScaler: 0,
+            offset: 0
+        }
+    },
+    // Supply url to local terrain worker bundle. Only required if running offline and cannot access CDN.
+    workerUrl: '',
+    // Same as SimpleMeshLayer wireframe
+    wireframe: false,
+    material: true,
+    loaders: [TerrainWorkerLoader]
+};
+// Turns array of templates into a single string to work around shallow change
+function urlTemplateToUpdateTrigger(template) {
+    if (Array.isArray(template)) {
+        return template.join(';');
+    }
+    return template || '';
+}
+/** Render mesh surfaces from height map images. */
+export default class TerrainLayer extends CompositeLayer {
+    static { this.defaultProps = defaultProps; }
+    static { this.layerName = 'TerrainLayer'; }
+    updateState({ props, oldProps }) {
+        const elevationDataChanged = props.elevationData !== oldProps.elevationData;
+        if (elevationDataChanged) {
+            const { elevationData } = props;
+            const isTiled = elevationData &&
+                (Array.isArray(elevationData) ||
+                    (elevationData.includes('{x}') && elevationData.includes('{y}')));
+            this.setState({ isTiled });
+        }
+        // Reloading for single terrain mesh
+        const shouldReload = elevationDataChanged ||
+            props.meshMaxError !== oldProps.meshMaxError ||
+            props.elevationDecoder !== oldProps.elevationDecoder ||
+            props.bounds !== oldProps.bounds;
+        if (!this.state.isTiled && shouldReload) {
+            // When state.isTiled, elevationData cannot be an array
+            const terrain = this.loadTerrain(props);
+            this.setState({ terrain });
+        }
+        // TODO - remove in v9
+        // @ts-ignore
+        if (props.workerUrl) {
+            log.removed('workerUrl', 'loadOptions.terrain.workerUrl')();
+        }
+    }
+    loadTerrain({ elevationData, bounds, elevationDecoder, meshMaxError, signal }) {
+        if (!elevationData) {
+            return null;
+        }
+        let loadOptions = this.getLoadOptions();
+        loadOptions = {
+            ...loadOptions,
+            terrain: {
+                skirtHeight: this.state.isTiled ? meshMaxError * 2 : 0,
+                ...loadOptions?.terrain,
+                bounds,
+                meshMaxError,
+                elevationDecoder
+            }
+        };
+        const { fetch } = this.props;
+        return fetch(elevationData, { propName: 'elevationData', layer: this, loadOptions, signal });
+    }
+    getTiledTerrainData(tile) {
+        const { elevationData, fetch, texture, elevationDecoder, meshMaxError } = this.props;
+        const { viewport } = this.context;
+        const dataUrl = getURLFromTemplate(elevationData, tile);
+        const textureUrl = texture && getURLFromTemplate(texture, tile);
+        const { signal } = tile;
+        let bottomLeft = [0, 0];
+        let topRight = [0, 0];
+        if (viewport.isGeospatial) {
+            const bbox = tile.bbox;
+            bottomLeft = viewport.projectFlat([bbox.west, bbox.south]);
+            topRight = viewport.projectFlat([bbox.east, bbox.north]);
+        }
+        else {
+            const bbox = tile.bbox;
+            bottomLeft = [bbox.left, bbox.bottom];
+            topRight = [bbox.right, bbox.top];
+        }
+        const bounds = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
+        const terrain = this.loadTerrain({
+            elevationData: dataUrl,
+            bounds,
+            elevationDecoder,
+            meshMaxError,
+            signal
+        });
+        const surface = textureUrl
+            ? // If surface image fails to load, the tile should still be displayed
+                fetch(textureUrl, { propName: 'texture', layer: this, loaders: [], signal }).catch(_ => null)
+            : Promise.resolve(null);
+        return Promise.all([terrain, surface]);
+    }
+    renderSubLayers(props) {
+        const SubLayerClass = this.getSubLayerClass('mesh', SimpleMeshLayer);
+        const { color, wireframe, material } = this.props;
+        const { data } = props;
+        if (!data) {
+            return null;
+        }
+        const [mesh, texture] = data;
+        return new SubLayerClass(props, {
+            data: DUMMY_DATA,
+            mesh,
+            texture,
+            _instanced: false,
+            coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+            getPosition: d => [0, 0, 0],
+            getColor: color,
+            wireframe,
+            material
+        });
+    }
+    // Update zRange of viewport
+    onViewportLoad(tiles) {
+        if (!tiles) {
+            return;
+        }
+        const { zRange } = this.state;
+        const ranges = tiles
+            .map(tile => tile.content)
+            .filter(Boolean)
+            .map(arr => {
+            // @ts-ignore
+            const bounds = arr[0].header.boundingBox;
+            return bounds.map(bound => bound[2]);
+        });
+        if (ranges.length === 0) {
+            return;
+        }
+        const minZ = Math.min(...ranges.map(x => x[0]));
+        const maxZ = Math.max(...ranges.map(x => x[1]));
+        if (!zRange || minZ < zRange[0] || maxZ > zRange[1]) {
+            this.setState({ zRange: [minZ, maxZ] });
+        }
+    }
+    renderLayers() {
+        const { color, material, elevationData, texture, wireframe, meshMaxError, elevationDecoder, tileSize, maxZoom, minZoom, extent, maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy } = this.props;
+        if (this.state.isTiled) {
+            return new TileLayer(this.getSubLayerProps({
+                id: 'tiles'
+            }), {
+                getTileData: this.getTiledTerrainData.bind(this),
+                renderSubLayers: this.renderSubLayers.bind(this),
+                updateTriggers: {
+                    getTileData: {
+                        elevationData: urlTemplateToUpdateTrigger(elevationData),
+                        texture: urlTemplateToUpdateTrigger(texture),
+                        meshMaxError,
+                        elevationDecoder
+                    }
+                },
+                onViewportLoad: this.onViewportLoad.bind(this),
+                zRange: this.state.zRange || null,
+                tileSize,
+                maxZoom,
+                minZoom,
+                extent,
+                maxRequests,
+                onTileLoad,
+                onTileUnload,
+                onTileError,
+                maxCacheSize,
+                maxCacheByteSize,
+                refinementStrategy
+            });
+        }
+        if (!elevationData) {
+            return null;
+        }
+        const SubLayerClass = this.getSubLayerClass('mesh', SimpleMeshLayer);
+        return new SubLayerClass(this.getSubLayerProps({
+            id: 'mesh'
+        }), {
+            data: DUMMY_DATA,
+            mesh: this.state.terrain,
+            texture,
+            _instanced: false,
+            getPosition: d => [0, 0, 0],
+            getColor: color,
+            material,
+            wireframe
+        });
+    }
+}

package/{typed → dist}/tile-3d-layer/tile-3d-layer.d.ts

@@ -45,7 +45,21 @@ export default class Tile3DLayer<DataT = any, ExtraPropsT extends {} = {}> exten
     shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
     updateState({ props, oldProps, changeFlags }: UpdateParameters<this>): void;
     activateViewport(viewport: Viewport): void;
-    getPickingInfo({ info, sourceLayer }: GetPickingInfoParams): PickingInfo;
+    getPickingInfo({ info, sourceLayer }: GetPickingInfoParams): {
+        color: Uint8Array | null;
+        layer: Layer<{}> | null;
+        sourceLayer?: Layer<{}> | null | undefined;
+        viewport?: Viewport | undefined;
+        index: number;
+        picked: boolean;
+        object?: any;
+        x: number;
+        y: number;
+        pixel?: [number, number] | undefined;
+        coordinate?: number[] | undefined;
+        devicePixel?: [number, number] | undefined;
+        pixelRatio: number;
+    };
     filterSubLayer({ layer, viewport }: FilterContext): boolean;
     protected _updateAutoHighlight(info: PickingInfo): void;
     private _loadTileset;

package/{typed → dist}/tile-3d-layer/tile-3d-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tile-3d-layer.d.ts","sourceRoot":"","sources":["../../src/tile-3d-layer/tile-3d-layer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tile-3d-layer.d.ts","sourceRoot":"","sources":["../../src/tile-3d-layer/tile-3d-layer.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,cAAc,EACd,mBAAmB,EAEnB,aAAa,EACb,oBAAoB,EACpB,KAAK,EACL,UAAU,EAEV,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACb,MAAM,eAAe,CAAC;AAOvB,OAAO,EAAC,SAAS,EAAE,MAAM,EAAY,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAmBnD,8CAA8C;AAC9C,MAAM,MAAM,gBAAgB,CAAC,KAAK,GAAG,OAAO,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC;AAE/F,qCAAqC;AACrC,KAAK,iBAAiB,CAAC,KAAK,IAAI;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,aAAa,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEvC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,aAAa,CAAC;IAE9B,gDAAgD;IAChD,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAE1C,8DAA8D;IAC9D,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEpC,uCAAuC;IACvC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC,yCAAyC;IACzC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnE,4EAA4E;IAC5E,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;CACzC,CAAC;AAEF,oLAAoL;AACpL,MAAM,CAAC,OAAO,OAAO,WAAW,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,cAAc,CAC/F,WAAW,GAAG,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CACjD;IACC,MAAM,CAAC,YAAY,0CAAgB;IACnC,MAAM,CAAC,SAAS,SAAiB;IAEjC,KAAK,EAAG;QACN,eAAe,EAAE,EAAE,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,oBAAoB,EAAE;YAAC,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAA;SAAC,GAAG,IAAI,CAAC;QAC9D,QAAQ,EAAE;YAAC,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;SAAC,CAAC;QACnC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;KAC7B,CAAC;IAEF,eAAe;IAaf,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,iBAAiB,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,OAAO;IAIjE,WAAW,CAAC,EAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAuBzE,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAY1C,cAAc,CAAC,EAAC,IAAI,EAAE,WAAW,EAAC,EAAE,oBAAoB;;;;;;;;;;;;;;;IAUxD,cAAc,CAAC,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,aAAa,GAAG,OAAO;IAOzD,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;YAQzC,YAAY;IA0C1B,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,YAAY;IAoBpB,OAAO,CAAC,oBAAoB;IA4C5B,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,oBAAoB;IA2C5B,YAAY,IAAI,KAAK,GAAG,IAAI,GAAG,UAAU;CA2B1C"}

package/dist/tile-3d-layer/tile-3d-layer.js

@@ -0,0 +1,302 @@
+import { Geometry } from '@luma.gl/engine';
+import { CompositeLayer, COORDINATE_SYSTEM, log } from '@deck.gl/core';
+import { PointCloudLayer } from '@deck.gl/layers';
+import { ScenegraphLayer } from '@deck.gl/mesh-layers';
+import { default as MeshLayer } from "../mesh-layer/mesh-layer.js";
+import { load } from '@loaders.gl/core';
+import { Tileset3D, TILE_TYPE } from '@loaders.gl/tiles';
+import { Tiles3DLoader } from '@loaders.gl/3d-tiles';
+const SINGLE_DATA = [0];
+const defaultProps = {
+    getPointColor: { type: 'accessor', value: [0, 0, 0, 255] },
+    pointSize: 1.0,
+    // Disable async data loading (handling it in _loadTileSet)
+    data: '',
+    loader: Tiles3DLoader,
+    onTilesetLoad: { type: 'function', value: tileset3d => { } },
+    onTileLoad: { type: 'function', value: tileHeader => { } },
+    onTileUnload: { type: 'function', value: tileHeader => { } },
+    onTileError: { type: 'function', value: (tile, message, url) => { } },
+    _getMeshColor: { type: 'function', value: tileHeader => [255, 255, 255] }
+};
+/** Render 3d tiles data formatted according to the [3D Tiles Specification](https://www.opengeospatial.org/standards/3DTiles) and [`ESRI I3S`](https://github.com/Esri/i3s-spec) */
+export default class Tile3DLayer extends CompositeLayer {
+    static { this.defaultProps = defaultProps; }
+    static { this.layerName = 'Tile3DLayer'; }
+    initializeState() {
+        if ('onTileLoadFail' in this.props) {
+            log.removed('onTileLoadFail', 'onTileError')();
+        }
+        // prop verification
+        this.state = {
+            layerMap: {},
+            tileset3d: null,
+            activeViewports: {},
+            lastUpdatedViewports: null
+        };
+    }
+    get isLoaded() {
+        return Boolean(this.state?.tileset3d?.isLoaded() && super.isLoaded);
+    }
+    shouldUpdateState({ changeFlags }) {
+        return changeFlags.somethingChanged;
+    }
+    updateState({ props, oldProps, changeFlags }) {
+        if (props.data && props.data !== oldProps.data) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this._loadTileset(props.data);
+        }
+        if (changeFlags.viewportChanged) {
+            const { activeViewports } = this.state;
+            const viewportsNumber = Object.keys(activeViewports).length;
+            if (viewportsNumber) {
+                this._updateTileset(activeViewports);
+                this.state.lastUpdatedViewports = activeViewports;
+                this.state.activeViewports = {};
+            }
+        }
+        if (changeFlags.propsChanged) {
+            const { layerMap } = this.state;
+            for (const key in layerMap) {
+                layerMap[key].needsUpdate = true;
+            }
+        }
+    }
+    activateViewport(viewport) {
+        const { activeViewports, lastUpdatedViewports } = this.state;
+        this.internalState.viewport = viewport;
+        activeViewports[viewport.id] = viewport;
+        const lastViewport = lastUpdatedViewports?.[viewport.id];
+        if (!lastViewport || !viewport.equals(lastViewport)) {
+            this.setChangeFlags({ viewportChanged: true });
+            this.setNeedsUpdate();
+        }
+    }
+    getPickingInfo({ info, sourceLayer }) {
+        const sourceTile = sourceLayer && sourceLayer.props.tile;
+        if (info.picked) {
+            info.object = sourceTile;
+        }
+        info.sourceTile = sourceTile;
+        return info;
+    }
+    filterSubLayer({ layer, viewport }) {
+        // All sublayers will have a tile prop
+        const { tile } = layer.props;
+        const { id: viewportId } = viewport;
+        return tile.selected && tile.viewportIds.includes(viewportId);
+    }
+    _updateAutoHighlight(info) {
+        const sourceTile = info.sourceTile;
+        const layerCache = this.state.layerMap[sourceTile?.id];
+        if (layerCache && layerCache.layer) {
+            layerCache.layer.updateAutoHighlight(info);
+        }
+    }
+    async _loadTileset(tilesetUrl) {
+        const { loadOptions = {} } = this.props;
+        // TODO: deprecate `loader` in v9.0
+        // @ts-ignore
+        const loaders = this.props.loader || this.props.loaders;
+        const loader = Array.isArray(loaders) ? loaders[0] : loaders;
+        const options = { loadOptions: { ...loadOptions } };
+        let actualTilesetUrl = tilesetUrl;
+        if (loader.preload) {
+            const preloadOptions = await loader.preload(tilesetUrl, loadOptions);
+            if (preloadOptions.url) {
+                actualTilesetUrl = preloadOptions.url;
+            }
+            if (preloadOptions.headers) {
+                options.loadOptions.fetch = {
+                    ...options.loadOptions.fetch,
+                    headers: preloadOptions.headers
+                };
+            }
+            Object.assign(options, preloadOptions);
+        }
+        const tilesetJson = await load(actualTilesetUrl, loader, options.loadOptions);
+        const tileset3d = new Tileset3D(tilesetJson, {
+            onTileLoad: this._onTileLoad.bind(this),
+            onTileUnload: this._onTileUnload.bind(this),
+            onTileError: this.props.onTileError,
+            ...options
+        });
+        this.setState({
+            tileset3d,
+            layerMap: {}
+        });
+        this._updateTileset(this.state.activeViewports);
+        this.props.onTilesetLoad(tileset3d);
+    }
+    _onTileLoad(tileHeader) {
+        const { lastUpdatedViewports } = this.state;
+        this.props.onTileLoad(tileHeader);
+        this._updateTileset(lastUpdatedViewports);
+        this.setNeedsUpdate();
+    }
+    _onTileUnload(tileHeader) {
+        // Was cleaned up from tileset cache. We no longer need to track it.
+        delete this.state.layerMap[tileHeader.id];
+        this.props.onTileUnload(tileHeader);
+    }
+    _updateTileset(viewports) {
+        if (!viewports) {
+            return;
+        }
+        const { tileset3d } = this.state;
+        const { timeline } = this.context;
+        const viewportsNumber = Object.keys(viewports).length;
+        if (!timeline || !viewportsNumber || !tileset3d) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        tileset3d.selectTiles(Object.values(viewports)).then(frameNumber => {
+            const tilesetChanged = this.state.frameNumber !== frameNumber;
+            if (tilesetChanged) {
+                this.setState({ frameNumber });
+            }
+        });
+    }
+    _getSubLayer(tileHeader, oldLayer) {
+        if (!tileHeader.content) {
+            return null;
+        }
+        switch (tileHeader.type) {
+            case TILE_TYPE.POINTCLOUD:
+                return this._makePointCloudLayer(tileHeader, oldLayer);
+            case TILE_TYPE.SCENEGRAPH:
+                return this._make3DModelLayer(tileHeader);
+            case TILE_TYPE.MESH:
+                return this._makeSimpleMeshLayer(tileHeader, oldLayer);
+            default:
+                throw new Error(`Tile3DLayer: Failed to render layer of type ${tileHeader.content.type}`);
+        }
+    }
+    _makePointCloudLayer(tileHeader, oldLayer) {
+        const { attributes, pointCount, constantRGBA, cartographicOrigin, modelMatrix } = tileHeader.content;
+        const { positions, normals, colors } = attributes;
+        if (!positions) {
+            return null;
+        }
+        const data = (oldLayer && oldLayer.props.data) || {
+            header: {
+                vertexCount: pointCount
+            },
+            attributes: {
+                POSITION: positions,
+                NORMAL: normals,
+                COLOR_0: colors
+            }
+        };
+        const { pointSize, getPointColor } = this.props;
+        const SubLayerClass = this.getSubLayerClass('pointcloud', PointCloudLayer);
+        return new SubLayerClass({
+            pointSize
+        }, this.getSubLayerProps({
+            id: 'pointcloud'
+        }), {
+            id: `${this.id}-pointcloud-${tileHeader.id}`,
+            tile: tileHeader,
+            data,
+            coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+            coordinateOrigin: cartographicOrigin,
+            modelMatrix,
+            getColor: constantRGBA || getPointColor,
+            _offset: 0
+        });
+    }
+    _make3DModelLayer(tileHeader) {
+        const { gltf, instances, cartographicOrigin, modelMatrix } = tileHeader.content;
+        const SubLayerClass = this.getSubLayerClass('scenegraph', ScenegraphLayer);
+        return new SubLayerClass({
+            _lighting: 'pbr'
+        }, this.getSubLayerProps({
+            id: 'scenegraph'
+        }), {
+            id: `${this.id}-scenegraph-${tileHeader.id}`,
+            tile: tileHeader,
+            data: instances || SINGLE_DATA,
+            scenegraph: gltf,
+            coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+            coordinateOrigin: cartographicOrigin,
+            modelMatrix,
+            getTransformMatrix: instance => instance.modelMatrix,
+            getPosition: [0, 0, 0],
+            _offset: 0
+        });
+    }
+    _makeSimpleMeshLayer(tileHeader, oldLayer) {
+        const content = tileHeader.content;
+        const { attributes, indices, modelMatrix, cartographicOrigin, coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS, material, featureIds } = content;
+        const { _getMeshColor } = this.props;
+        const geometry = (oldLayer && oldLayer.props.mesh) ||
+            new Geometry({
+                topology: 'triangle-list',
+                attributes: getMeshGeometry(attributes),
+                indices
+            });
+        const SubLayerClass = this.getSubLayerClass('mesh', MeshLayer);
+        return new SubLayerClass(this.getSubLayerProps({
+            id: 'mesh'
+        }), {
+            id: `${this.id}-mesh-${tileHeader.id}`,
+            tile: tileHeader,
+            mesh: geometry,
+            data: SINGLE_DATA,
+            getColor: _getMeshColor(tileHeader),
+            pbrMaterial: material,
+            modelMatrix,
+            coordinateOrigin: cartographicOrigin,
+            coordinateSystem,
+            featureIds,
+            _offset: 0
+        });
+    }
+    renderLayers() {
+        const { tileset3d, layerMap } = this.state;
+        if (!tileset3d) {
+            return null;
+        }
+        // loaders.gl doesn't provide a type for tileset3d.tiles
+        return tileset3d.tiles
+            .map(tile => {
+            const layerCache = (layerMap[tile.id] = layerMap[tile.id] || { tile });
+            let { layer } = layerCache;
+            if (tile.selected) {
+                // render selected tiles
+                if (!layer) {
+                    // create layer
+                    layer = this._getSubLayer(tile);
+                }
+                else if (layerCache.needsUpdate) {
+                    // props have changed, rerender layer
+                    layer = this._getSubLayer(tile, layer);
+                    layerCache.needsUpdate = false;
+                }
+            }
+            layerCache.layer = layer;
+            return layer;
+        })
+            .filter(Boolean);
+    }
+}
+function getMeshGeometry(contentAttributes) {
+    const attributes = {};
+    attributes.positions = {
+        ...contentAttributes.positions,
+        value: new Float32Array(contentAttributes.positions.value)
+    };
+    if (contentAttributes.normals) {
+        attributes.normals = contentAttributes.normals;
+    }
+    if (contentAttributes.texCoords) {
+        attributes.texCoords = contentAttributes.texCoords;
+    }
+    if (contentAttributes.colors) {
+        attributes.colors = contentAttributes.colors;
+    }
+    if (contentAttributes.uvRegions) {
+        attributes.uvRegions = contentAttributes.uvRegions;
+    }
+    return attributes;
+}

package/{typed → dist}/tile-layer/tile-layer.d.ts

@@ -1,8 +1,8 @@
 import { CompositeLayer, CompositeLayerProps, Layer, LayerProps, UpdateParameters, PickingInfo, GetPickingInfoParams, DefaultProps, FilterContext } from '@deck.gl/core';
 import { LayersList } from '@deck.gl/core';
-import type { TileLoadProps, ZRange } from '../tileset-2d';
-import { Tileset2D, Tile2DHeader, RefinementStrategy, Tileset2DProps } from '../tileset-2d';
-import { URLTemplate } from '../tileset-2d';
+import type { TileLoadProps, ZRange } from "../tileset-2d/index.js";
+import { Tileset2D, Tile2DHeader, RefinementStrategy, Tileset2DProps } from "../tileset-2d/index.js";
+import { URLTemplate } from "../tileset-2d/index.js";
 /** All props supported by the TileLayer */
 export type TileLayerProps<DataT = unknown> = CompositeLayerProps & _TileLayerProps<DataT>;
 /** Props added by the TileLayer */
@@ -67,6 +67,12 @@ type _TileLayerProps<DataT> = {
      * @default 6
      */
     maxRequests?: number;
+    /**
+     * Queue tile requests until no new tiles have been requested for at least `debounceTime` milliseconds.
+     *
+     * @default 0
+     */
+    debounceTime?: number;
     /**
      * This offset changes the zoom level at which the tiles are fetched.
      *
@@ -76,8 +82,13 @@ type _TileLayerProps<DataT> = {
      */
     zoomOffset?: number;
 };
-export type TiledPickingInfo<DataT = any> = PickingInfo & {
+export type TileLayerPickingInfo<DataT = any, SubLayerPickingInfo = PickingInfo> = SubLayerPickingInfo & {
+    /** The picked tile */
     tile?: Tile2DHeader<DataT>;
+    /** the tile that emitted the picking event */
+    sourceTile: Tile2DHeader<DataT>;
+    /** a layer created by props.renderSubLayer() that emitted the picking event */
+    sourceTileSubLayer: Layer;
 };
 /**
  * The TileLayer is a composite layer that makes it possible to visualize very large datasets.
@@ -113,8 +124,8 @@ export default class TileLayer<DataT = any, ExtraPropsT extends {} = {}> extends
         tile: Tile2DHeader<DataT>;
     }): Layer | null | LayersList;
     getSubLayerPropsByTile(tile: Tile2DHeader): Partial<LayerProps> | null;
-    getPickingInfo({ info, sourceLayer }: GetPickingInfoParams): TiledPickingInfo<DataT>;
-    protected _updateAutoHighlight(info: PickingInfo): void;
+    getPickingInfo(params: GetPickingInfoParams): TileLayerPickingInfo<DataT>;
+    protected _updateAutoHighlight(info: TileLayerPickingInfo<DataT>): void;
     renderLayers(): Layer | null | LayersList;
     filterSubLayer({ layer, cullRect }: FilterContext): boolean;
 }

package/dist/tile-layer/tile-layer.d.ts.map

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