@sakuzu/maplibre-gl-draw 1.0.0

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

@@ -0,0 +1,174 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { INACTIVE_TERRAIN_STATE, } from '../terrain/context.js';
+import { DemAtlas } from '../terrain/dem-atlas.js';
+import { getMapTerrain, getRenderableTerrainTiles, getTerrainMeshSize } from '../terrain/detect.js';
+import { circumferenceAtLatitude, metersToMercatorScale, TERRAIN_REGION_MARGIN, terrainLiftMeters, } from '../terrain/metrics.js';
+import { atlasCoverage, containsRect, expandRect, intersectRect, mercatorX, mercatorY, } from '../terrain/tessellation.js';
+import { buildTessellationTiling } from '../terrain/tiling.js';
+/**
+ * Resolves the terrain state frame by frame
+ *
+ * @internal
+ */
+export class TerrainResolver {
+    constructor(map, terrainContext) {
+        Object.defineProperty(this, "map", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "terrainContext", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * DEM atlas (used only in the frames where the terrain is active)
+         *
+         * No GL resource is created on a map where the terrain never becomes active (lazy creation).
+         */
+        Object.defineProperty(this, "demAtlas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Key of the conditions under which the tile step index was built most recently */
+        Object.defineProperty(this, "tilingCacheKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        this.map = map;
+        this.terrainContext = terrainContext;
+    }
+    /**
+     * Resolves the terrain state of this frame
+     *
+     * It returns INACTIVE when there is no terrain or when not a single DEM has arrived yet.
+     * Making "terrain present but DEM empty" active would only leave the features pinned at sea
+     * level and fighting the terrain mesh (also flat, with the same empty DEM), so staying with the
+     * previous rendering is safer.
+     */
+    resolve(gl) {
+        const map = this.map;
+        const terrainContext = this.terrainContext;
+        const terrain = getMapTerrain(map);
+        if (!terrain || !gl)
+            return this.markInactive();
+        if (!this.demAtlas)
+            this.demAtlas = new DemAtlas(gl);
+        const center = map.getCenter();
+        // The tiles are placed around the camera (across the antimeridian the two ends of the world
+        // sit next to each other in the atlas)
+        const atlas = this.demAtlas.build(terrain, mercatorX(center.lng), map.areTilesLoaded?.() === true);
+        if (!atlas)
+            return this.markInactive();
+        const centerLat = center.lat;
+        const circumference = circumferenceAtLatitude(centerLat);
+        // The subdivision grid is placed exactly on the nodes of the terrain mesh of MapLibre.
+        // The node spacing is 1/(2^z * meshSize) (in mercator units).
+        const meshSize = getTerrainMeshSize(terrain);
+        const stepGrid = 1 / (2 ** atlas.maxTileZoom * meshSize);
+        const stepMeters = stepGrid * circumference;
+        let stepChanged = false;
+        // The ratio by which the step got finer. The shapes already baked are coarse by that ratio,
+        // so it is used as the initial value of the depth bias (this keeps a hole from appearing for
+        // one frame before the re-bake; the retained batch side also reports its own ratio on every
+        // draw)
+        let staleRatio = 1;
+        if (stepGrid !== terrainContext.stepGrid) {
+            if (terrainContext.stepGrid > stepGrid && stepGrid > 0) {
+                staleRatio = terrainContext.stepGrid / stepGrid;
+            }
+            terrainContext.stepGrid = stepGrid;
+            stepChanged = true;
+        }
+        // Decide the region that may be subdivided. It is taken again only when the step changed and
+        // when the region now needed left the previous region (following it every frame would re-bake
+        // the retained batches).
+        //
+        // The needed region is "the DEM atlas ∩ the view". Outside the atlas the elevation is capped
+        // at the value of the edge, so subdividing there is pointless, and outside the view nobody
+        // sees it. The atlas spreads up to 8 of the finest tiles (at most 2048 texels), so it is
+        // often much wider than the view. At zoom 13 the view was 15 km while the atlas was 39 km,
+        // and the features being subdivided ballooned by a factor of 6.
+        const covered = this.visibleTessellationRect(atlasCoverage(atlas.rect));
+        const region = terrainContext.tessellationRegion;
+        if (stepChanged || !region || !containsRect(region, covered)) {
+            terrainContext.tessellationRegion = expandRect(covered, TERRAIN_REGION_MARGIN);
+            terrainContext.generation++;
+            // The coarseness is measured again for each generation (the value of the previous
+            // generation is not carried over)
+            terrainContext.tessellationCoarsening = staleRatio;
+        }
+        // Index of the real mesh step per tile. Rebuilt when the region or the tile set changed
+        const tilingKey = `${terrainContext.generation}|${terrainContext.coverageKey}`;
+        if (tilingKey !== this.tilingCacheKey) {
+            this.tilingCacheKey = tilingKey;
+            terrainContext.tessellationTiling = buildTessellationTiling(getRenderableTerrainTiles(terrain), meshSize, terrainContext.tessellationRegion);
+        }
+        return {
+            active: true,
+            atlasTexture: atlas.texture,
+            atlasRect: atlas.rect,
+            atlasSize: atlas.size,
+            elevationScale: metersToMercatorScale(centerLat),
+            liftMeters: terrainLiftMeters(atlas.maxTileZoom, centerLat),
+            stepMeters,
+            stepGrid,
+            tessellationRegion: terrainContext.tessellationRegion,
+            tessellationTiling: terrainContext.tessellationTiling,
+            generation: terrainContext.generation,
+        };
+    }
+    /** Drops the DEM atlas and the key of the index (the GPU side went away) */
+    releaseGpu() {
+        if (this.demAtlas) {
+            this.demAtlas.dispose();
+            this.demAtlas = null;
+        }
+        this.tilingCacheKey = '';
+    }
+    /**
+     * The region that currently needs subdivision (atlas ∩ view)
+     *
+     * maplibre reports the view with unwrapped longitudes (across the antimeridian the east edge
+     * is above 180), which is the frame the atlas is placed in as well (the copy nearest to the
+     * camera). When the view cannot be obtained or does not form a rectangle, the atlas is
+     * returned (it only subdivides too much; the picture is correct).
+     */
+    visibleTessellationRect(atlasRect) {
+        const bounds = this.map?.getBounds?.();
+        if (!bounds)
+            return atlasRect;
+        const west = bounds.getWest();
+        const east = bounds.getEast();
+        const south = bounds.getSouth();
+        const north = bounds.getNorth();
+        if (!(east > west) || !(north > south))
+            return atlasRect;
+        const view = {
+            x0: mercatorX(west),
+            y0: mercatorY(north),
+            x1: mercatorX(east),
+            y1: mercatorY(south),
+        };
+        return intersectRect(atlasRect, view) ?? atlasRect;
+    }
+    /**
+     * Falls back to no terrain (the step counts as changed, so the generation is advanced)
+     */
+    markInactive() {
+        const terrainContext = this.terrainContext;
+        if (terrainContext.stepGrid !== 0) {
+            terrainContext.stepGrid = 0;
+            terrainContext.generation++;
+        }
+        return { ...INACTIVE_TERRAIN_STATE, generation: terrainContext.generation };
+    }
+}

package/dist/view/renderers/batch-manager.d.ts

@@ -0,0 +1,61 @@
+import type { Coordinate } from '../../store/types.js';
+import { TerrainContext } from '../terrain/context.js';
+import type { FeatureDrawer } from './drawer.js';
+import type { LineBatchItem, LineBatchShape } from './line/line-types.js';
+import type { SDFLineRenderer, SDFStrokeStyle } from './line/sdf-line.js';
+import { type PointInstanceDataFull, type PointInstanceRenderer } from './point/point-instance.js';
+import type { PointStyle } from './point/point-shape.js';
+import type { PolygonBatchRenderer } from './polygon/batch.js';
+import type { SDFPolygonRenderer } from './polygon/sdf-polygon.js';
+/**
+ * The dependencies of BatchManager
+ */
+export interface BatchManagerDeps {
+    gl: WebGL2RenderingContext;
+    featureDrawer: FeatureDrawer;
+    pointInstanceRenderer: PointInstanceRenderer;
+    sdfLineRenderer: SDFLineRenderer;
+    polygonBatchRenderer: PolygonBatchRenderer;
+    sdfPolygonRenderer: SDFPolygonRenderer;
+    /** The terrain state of the draw instance (occlusion of the points; flat when omitted) */
+    terrain?: TerrainContext;
+}
+/**
+ * Convert a Point style into instance data
+ *
+ * The opacity is folded into the alpha of the color, and the stroke is disabled
+ * by setting its width to 0 when its opacity is 0.
+ */
+export declare function toPointInstanceData(coord: Coordinate, style: PointStyle): PointInstanceDataFull;
+/**
+ * Convert a Point style into the packed style of `PackedPointInstances`
+ *
+ * The same values as `toPointInstanceData` puts on a point, in the order fillColor, strokeColor,
+ * fillSize, strokeWidth.
+ */
+export declare function toPackedPointStyle(style: PointStyle): Float64Array;
+/**
+ * Convert a stroke style into an item of a line batch
+ *
+ * The color and the opacity are passed to the GPU as instance attributes, so
+ * they are expanded from the style down to the per-item level. The dash kind and
+ * the reference zoom of the width are handled on the shape side (the batch key
+ * and the instance attributes), so they are not included here.
+ */
+export declare function toLineBatchItem(coords: [number, number][], featureId: string, style: SDFStrokeStyle, createdZoom: number, closed?: boolean): LineBatchItem;
+/**
+ * Obtain the shape parameters of a line batch
+ *
+ * The color is an instance attribute, so it is not included. For solid lines the
+ * dash array is not used for rendering, so it is dropped to avoid pointless batch
+ * splits.
+ */
+export declare function toLineBatchShape(style: SDFStrokeStyle): LineBatchShape;
+/**
+ * Obtain the key of a line batch (shape parameters only; it does not depend on the color)
+ */
+export declare function lineBatchKey(shape: LineBatchShape): string;
+/**
+ * Create a BatchManager
+ */
+export declare function createBatchManager(deps: BatchManagerDeps): BatchManager;