@scoova/mgl 1.0.0

package/src/source/source_state.ts

@@ -0,0 +1,157 @@
+import {extend} from '../util/util';
+import {Tile} from './tile';
+import type {FeatureState} from '@maplibre/maplibre-gl-style-spec';
+
+export type FeatureStates = {[featureId: string]: FeatureState};
+export type LayerFeatureStates = {[layer: string]: FeatureStates};
+
+/**
+ * @internal
+ * SourceFeatureState manages the state and pending changes
+ * to features in a source, separated by source layer.
+ * stateChanges and deletedStates batch all changes to the tile (updates and removes, respectively)
+ * between coalesce() events. addFeatureState() and removeFeatureState() also update their counterpart's
+ * list of changes, such that coalesce() can apply the proper state changes while agnostic to the order of operations.
+ * In deletedStates, all null's denote complete removal of state at that scope
+*/
+export class SourceFeatureState {
+    state: LayerFeatureStates;
+    stateChanges: LayerFeatureStates;
+    deletedStates: {};
+
+    constructor() {
+        this.state = {};
+        this.stateChanges = {};
+        this.deletedStates = {};
+    }
+
+    updateState(sourceLayer: string, featureId: number | string, newState: any) {
+        const feature = String(featureId);
+        this.stateChanges[sourceLayer] = this.stateChanges[sourceLayer] || {};
+        this.stateChanges[sourceLayer][feature] = this.stateChanges[sourceLayer][feature] || {};
+        extend(this.stateChanges[sourceLayer][feature], newState);
+
+        if (this.deletedStates[sourceLayer] === null) {
+            this.deletedStates[sourceLayer] = {};
+            for (const ft in this.state[sourceLayer]) {
+                if (ft !== feature) this.deletedStates[sourceLayer][ft] = null;
+            }
+        } else {
+            const featureDeletionQueued = this.deletedStates[sourceLayer] && this.deletedStates[sourceLayer][feature] === null;
+            if (featureDeletionQueued) {
+                this.deletedStates[sourceLayer][feature] = {};
+                for (const prop in this.state[sourceLayer][feature]) {
+                    if (!newState[prop]) this.deletedStates[sourceLayer][feature][prop] = null;
+                }
+            } else {
+                for (const key in newState) {
+                    const deletionInQueue = this.deletedStates[sourceLayer] && this.deletedStates[sourceLayer][feature] && this.deletedStates[sourceLayer][feature][key] === null;
+                    if (deletionInQueue) delete this.deletedStates[sourceLayer][feature][key];
+                }
+            }
+        }
+    }
+
+    removeFeatureState(sourceLayer: string, featureId?: number | string, key?: string) {
+        const sourceLayerDeleted = this.deletedStates[sourceLayer] === null;
+        if (sourceLayerDeleted) return;
+
+        const feature = String(featureId);
+
+        this.deletedStates[sourceLayer] = this.deletedStates[sourceLayer] || {};
+
+        if (key && featureId !== undefined) {
+            if (this.deletedStates[sourceLayer][feature] !== null) {
+                this.deletedStates[sourceLayer][feature] = this.deletedStates[sourceLayer][feature] || {};
+                this.deletedStates[sourceLayer][feature][key] = null;
+            }
+        } else if (featureId !== undefined) {
+            const updateInQueue = this.stateChanges[sourceLayer] && this.stateChanges[sourceLayer][feature];
+            if (updateInQueue) {
+                this.deletedStates[sourceLayer][feature] = {};
+                for (key in this.stateChanges[sourceLayer][feature]) this.deletedStates[sourceLayer][feature][key] = null;
+
+            } else {
+                this.deletedStates[sourceLayer][feature] = null;
+            }
+        } else {
+            this.deletedStates[sourceLayer] = null;
+        }
+
+    }
+
+    getState(sourceLayer: string, featureId: number | string) {
+        const feature = String(featureId);
+        const base = this.state[sourceLayer] || {};
+        const changes = this.stateChanges[sourceLayer] || {};
+
+        const reconciledState = extend({}, base[feature], changes[feature]);
+
+        //return empty object if the whole source layer is awaiting deletion
+        if (this.deletedStates[sourceLayer] === null) return {};
+        else if (this.deletedStates[sourceLayer]) {
+            const featureDeletions = this.deletedStates[sourceLayer][featureId];
+            if (featureDeletions === null) return {};
+            for (const prop in featureDeletions) delete reconciledState[prop];
+        }
+        return reconciledState;
+    }
+
+    initializeTileState(tile: Tile, painter: any) {
+        tile.setFeatureState(this.state, painter);
+    }
+
+    coalesceChanges(tiles: {
+        [_ in any]: Tile;
+    }, painter: any) {
+        //track changes with full state objects, but only for features that got modified
+        const featuresChanged: LayerFeatureStates = {};
+
+        for (const sourceLayer in this.stateChanges) {
+            this.state[sourceLayer]  = this.state[sourceLayer] || {};
+            const layerStates = {};
+            for (const feature in this.stateChanges[sourceLayer]) {
+                if (!this.state[sourceLayer][feature]) this.state[sourceLayer][feature] = {};
+                extend(this.state[sourceLayer][feature], this.stateChanges[sourceLayer][feature]);
+                layerStates[feature] = this.state[sourceLayer][feature];
+            }
+            featuresChanged[sourceLayer] = layerStates;
+        }
+
+        for (const sourceLayer in this.deletedStates) {
+            this.state[sourceLayer]  = this.state[sourceLayer] || {};
+            const layerStates = {};
+
+            if (this.deletedStates[sourceLayer] === null) {
+                for (const ft in this.state[sourceLayer]) {
+                    layerStates[ft] = {};
+                    this.state[sourceLayer][ft] = {};
+                }
+            } else {
+                for (const feature in this.deletedStates[sourceLayer]) {
+                    const deleteWholeFeatureState = this.deletedStates[sourceLayer][feature] === null;
+                    if (deleteWholeFeatureState) this.state[sourceLayer][feature] = {};
+                    else {
+                        for (const key of Object.keys(this.deletedStates[sourceLayer][feature])) {
+                            delete this.state[sourceLayer][feature][key];
+                        }
+                    }
+                    layerStates[feature] = this.state[sourceLayer][feature];
+                }
+            }
+
+            featuresChanged[sourceLayer] = featuresChanged[sourceLayer] || {};
+            extend(featuresChanged[sourceLayer], layerStates);
+        }
+
+        this.stateChanges = {};
+        this.deletedStates = {};
+
+        if (Object.keys(featuresChanged).length === 0) return;
+
+        for (const id in tiles) {
+            const tile = tiles[id];
+            tile.setFeatureState(featuresChanged, painter);
+        }
+    }
+}

package/src/source/terrain_source_cache.test.ts

@@ -0,0 +1,105 @@
+import {TerrainSourceCache} from './terrain_source_cache';
+import {Style} from '../style/style';
+import {RequestManager} from '../util/request_manager';
+import {Dispatcher} from '../util/dispatcher';
+import {fakeServer, type FakeServer} from 'nise';
+import {Transform} from '../geo/transform';
+import {Evented} from '../util/evented';
+import {Painter} from '../render/painter';
+import {RasterDEMTileSource} from './raster_dem_tile_source';
+import {OverscaledTileID} from './tile_id';
+import {Tile} from './tile';
+import {DEMData} from '../data/dem_data';
+
+const transform = new Transform();
+
+class StubMap extends Evented {
+    transform: Transform;
+    painter: Painter;
+    _requestManager: RequestManager;
+
+    constructor() {
+        super();
+        this.transform = transform;
+        this._requestManager = {
+            transformRequest: (url) => {
+                return {url};
+            }
+        } as any as RequestManager;
+    }
+
+    _getMapId() {
+        return 1;
+    }
+
+    setTerrain() {}
+}
+
+function createSource(options, transformCallback?) {
+    const source = new RasterDEMTileSource('id', options, {send() {}} as any as Dispatcher, null);
+    source.onAdd({
+        transform,
+        _requestManager: new RequestManager(transformCallback),
+        getPixelRatio() { return 1; }
+    } as any);
+
+    source.on('error', (e) => {
+        throw e.error;
+    });
+
+    return source;
+}
+
+describe('TerrainSourceCache', () => {
+    let server: FakeServer;
+    let style: Style;
+    let tsc: TerrainSourceCache;
+
+    beforeAll(() => new Promise<void>(done => {
+        global.fetch = null;
+        server = fakeServer.create();
+        server.respondWith('/source.json', JSON.stringify({
+            minzoom: 5,
+            maxzoom: 12,
+            attribution: 'MapLibre',
+            tiles: ['http://example.com/{z}/{x}/{y}.pngraw'],
+            bounds: [-47, -7, -45, -5]
+        }));
+        const map = new StubMap();
+        style = new Style(map as any);
+        style.on('style.load', () => {
+            const source = createSource({url: '/source.json'});
+            server.respond();
+            style.addSource('terrain', source as any);
+            tsc = new TerrainSourceCache(style.sourceCaches.terrain);
+            done();
+        });
+        style.loadJSON({
+            'version': 8,
+            'sources': {},
+            'layers': []
+        });
+    }));
+
+    afterAll(() => {
+        server.restore();
+    });
+
+    test('#constructor', () => {
+        expect(tsc.sourceCache.usedForTerrain).toBeTruthy();
+        expect(tsc.sourceCache.tileSize).toBe(tsc.tileSize * 2 ** tsc.deltaZoom);
+    });
+
+    test('#getSourceTile', () => {
+        const tileID = new OverscaledTileID(5, 0, 5, 17, 11);
+        const tile = new Tile(tileID, 256);
+        tile.dem = {} as DEMData;
+        tsc.sourceCache._tiles[tileID.key] = tile;
+        expect(tsc.deltaZoom).toBe(1);
+        expect(tsc.getSourceTile(tileID)).toBeFalsy();
+        expect(tsc.getSourceTile(tileID.children(12)[0])).toBeTruthy();
+        expect(tsc.getSourceTile(tileID.children(12)[0].children(12)[0])).toBeFalsy();
+        expect(tsc.getSourceTile(tileID.children(12)[0].children(12)[0], true)).toBeTruthy();
+    });
+
+});

package/src/source/terrain_source_cache.ts

@@ -0,0 +1,204 @@
+import {OverscaledTileID} from './tile_id';
+import {Tile} from './tile';
+import {EXTENT} from '../data/extent';
+import {mat4} from 'gl-matrix';
+import {Evented} from '../util/evented';
+import type {Transform} from '../geo/transform';
+import type {SourceCache} from '../source/source_cache';
+import {Terrain} from '../render/terrain';
+
+/**
+ * @internal
+ * This class is a helper for the Terrain-class, it:
+ *
+ * - loads raster-dem tiles
+ * - manages all renderToTexture tiles.
+ * - caches previous rendered tiles.
+ * - finds all necessary renderToTexture tiles for a OverscaledTileID area
+ * - finds the corresponding raster-dem tile for OverscaledTileID
+ */
+export class TerrainSourceCache extends Evented {
+    /**
+     * source-cache for the raster-dem source.
+     */
+    sourceCache: SourceCache;
+    /**
+     * stores all render-to-texture tiles.
+     */
+    _tiles: {[_: string]: Tile};
+    /**
+     * contains a list of tileID-keys for the current scene. (only for performance)
+     */
+    _renderableTilesKeys: Array<string>;
+    /**
+     * raster-dem-tile for a TileID cache.
+     */
+    _sourceTileCache: {[_: string]: string};
+    /**
+     * minimum zoomlevel to render the terrain.
+     */
+    minzoom: number;
+    /**
+     * maximum zoomlevel to render the terrain.
+     */
+    maxzoom: number;
+    /**
+     * render-to-texture tileSize in scene.
+     */
+    tileSize: number;
+    /**
+     * raster-dem tiles will load for performance the actualZoom - deltaZoom zoom-level.
+     */
+    deltaZoom: number;
+
+    constructor(sourceCache: SourceCache) {
+        super();
+        this.sourceCache = sourceCache;
+        this._tiles = {};
+        this._renderableTilesKeys = [];
+        this._sourceTileCache = {};
+        this.minzoom = 0;
+        this.maxzoom = 22;
+        this.tileSize = 512;
+        this.deltaZoom = 1;
+        sourceCache.usedForTerrain = true;
+        sourceCache.tileSize = this.tileSize * 2 ** this.deltaZoom;
+    }
+
+    destruct() {
+        this.sourceCache.usedForTerrain = false;
+        this.sourceCache.tileSize = null;
+    }
+
+    /**
+     * Load Terrain Tiles, create internal render-to-texture tiles, free GPU memory.
+     * @param transform - the operation to do
+     * @param terrain - the terrain
+     */
+    update(transform: Transform, terrain: Terrain): void {
+        // load raster-dem tiles for the current scene.
+        this.sourceCache.update(transform, terrain);
+        // create internal render-to-texture tiles for the current scene.
+        this._renderableTilesKeys = [];
+        const keys = {};
+        for (const tileID of transform.coveringTiles({
+            tileSize: this.tileSize,
+            minzoom: this.minzoom,
+            maxzoom: this.maxzoom,
+            reparseOverscaled: false,
+            terrain
+        })) {
+            keys[tileID.key] = true;
+            this._renderableTilesKeys.push(tileID.key);
+            if (!this._tiles[tileID.key]) {
+                tileID.posMatrix = new Float64Array(16) as any;
+                mat4.ortho(tileID.posMatrix, 0, EXTENT, 0, EXTENT, 0, 1);
+                this._tiles[tileID.key] = new Tile(tileID, this.tileSize);
+            }
+        }
+        // free unused tiles
+        for (const key in this._tiles) {
+            if (!keys[key]) delete this._tiles[key];
+        }
+    }
+
+    /**
+     * Free render to texture cache
+     * @param tileID - optional, free only corresponding to tileID.
+     */
+    freeRtt(tileID?: OverscaledTileID) {
+        for (const key in this._tiles) {
+            const tile = this._tiles[key];
+            if (!tileID || tile.tileID.equals(tileID) || tile.tileID.isChildOf(tileID) || tileID.isChildOf(tile.tileID))
+                tile.rtt = [];
+        }
+    }
+
+    /**
+     * get a list of tiles, which are loaded and should be rendered in the current scene
+     * @returns the renderable tiles
+     */
+    getRenderableTiles(): Array<Tile> {
+        return this._renderableTilesKeys.map(key => this.getTileByID(key));
+    }
+
+    /**
+     * get terrain tile by the TileID key
+     * @param id - the tile id
+     * @returns the tile
+     */
+    getTileByID(id: string): Tile {
+        return this._tiles[id];
+    }
+
+    /**
+     * Searches for the corresponding current renderable terrain-tiles
+     * @param tileID - the tile to look for
+     * @returns the tiles that were found
+     */
+    getTerrainCoords(tileID: OverscaledTileID): Record<string, OverscaledTileID> {
+        const coords = {};
+        for (const key of this._renderableTilesKeys) {
+            const _tileID = this._tiles[key].tileID;
+            if (_tileID.canonical.equals(tileID.canonical)) {
+                const coord = tileID.clone();
+                coord.posMatrix = new Float64Array(16) as any;
+                mat4.ortho(coord.posMatrix, 0, EXTENT, 0, EXTENT, 0, 1);
+                coords[key] = coord;
+            } else if (_tileID.canonical.isChildOf(tileID.canonical)) {
+                const coord = tileID.clone();
+                coord.posMatrix = new Float64Array(16) as any;
+                const dz = _tileID.canonical.z - tileID.canonical.z;
+                const dx = _tileID.canonical.x - (_tileID.canonical.x >> dz << dz);
+                const dy = _tileID.canonical.y - (_tileID.canonical.y >> dz << dz);
+                const size = EXTENT >> dz;
+                mat4.ortho(coord.posMatrix, 0, size, 0, size, 0, 1);
+                mat4.translate(coord.posMatrix, coord.posMatrix, [-dx * size, -dy * size, 0]);
+                coords[key] = coord;
+            } else if (tileID.canonical.isChildOf(_tileID.canonical)) {
+                const coord = tileID.clone();
+                coord.posMatrix = new Float64Array(16) as any;
+                const dz = tileID.canonical.z - _tileID.canonical.z;
+                const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz);
+                const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
+                const size = EXTENT >> dz;
+                mat4.ortho(coord.posMatrix, 0, EXTENT, 0, EXTENT, 0, 1);
+                mat4.translate(coord.posMatrix, coord.posMatrix, [dx * size, dy * size, 0]);
+                mat4.scale(coord.posMatrix, coord.posMatrix, [1 / (2 ** dz), 1 / (2 ** dz), 0]);
+                coords[key] = coord;
+            }
+        }
+        return coords;
+    }
+
+    /**
+     * find the covering raster-dem tile
+     * @param tileID - the tile to look for
+     * @param searchForDEM - Optional parameter to search for (parent) sourcetiles with loaded dem.
+     * @returns the tile
+     */
+    getSourceTile(tileID: OverscaledTileID, searchForDEM?: boolean): Tile {
+        const source = this.sourceCache._source;
+        let z = tileID.overscaledZ - this.deltaZoom;
+        if (z > source.maxzoom) z = source.maxzoom;
+        if (z < source.minzoom) return null;
+        // cache for tileID to terrain-tileID
+        if (!this._sourceTileCache[tileID.key])
+            this._sourceTileCache[tileID.key] = tileID.scaledTo(z).key;
+        let tile = this.sourceCache.getTileByID(this._sourceTileCache[tileID.key]);
+        // during tile-loading phase look if parent tiles (with loaded dem) are available.
+        if (!(tile && tile.dem) && searchForDEM)
+            while (z >= source.minzoom && !(tile && tile.dem))
+                tile = this.sourceCache.getTileByID(tileID.scaledTo(z--).key);
+        return tile;
+    }
+
+    /**
+     * get a list of tiles, loaded after a specific time. This is used to update depth & coords framebuffers.
+     * @param time - the time
+     * @returns the relevant tiles
+     */
+    tilesAfterTime(time = Date.now()): Array<Tile> {
+        return Object.values(this._tiles).filter(t => t.timeAdded >= time);
+    }
+}