@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/terrain/drape/binning.js

@@ -0,0 +1,604 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { DRAPE_BLOCK_EDGES, drapeQuantizedGeometry } from './geometry.js';
+/** The minimum number of divisions of the grid (per side) */
+export const DRAPE_MIN_CELLS = 8;
+/** The maximum number of divisions of the grid (per side) */
+export const DRAPE_MAX_CELLS = 64;
+/**
+ * The maximum number of divisions of the grid (per side) allowed on a retry
+ *
+ * Only when cells that exceed the budget remain is the grid made this fine and rebuilt.
+ */
+export const DRAPE_RETRY_MAX_CELLS = 128;
+/**
+ * The target number of edges to put into one cell (the grid is made finer so as not to exceed it)
+ *
+ * It is set at half of the upper limit of the work per pixel (DRAPE_MAX_CELL_WORK). If the
+ * target were the same as the limit, even a single straightforward feature would sit right at
+ * the limit and unnecessary quantization would be applied.
+ */
+export const DRAPE_TARGET_EDGES_PER_CELL = 12;
+/** The target number of elements to put into one cell (this decides the number of runs) */
+export const DRAPE_TARGET_ELEMENTS_PER_CELL = 4;
+/** The maximum number of edges one cell can hold (a cell that exceeds it signals degradation) */
+export const DRAPE_MAX_EDGES_PER_CELL = 256;
+/**
+ * The maximum number of runs (the span of one feature) one cell can hold
+ *
+ * A cell that exceeds it is truncated inside that cell alone (the elements at the back of the
+ * draw order = in front are dropped). The only cells this applies to are those of a coarse
+ * distant tile where dozens of items overlap in a single pixel. The map as a whole is never
+ * degraded.
+ */
+export const DRAPE_MAX_RUNS_PER_CELL = 128;
+/**
+ * The maximum number of edges handled by a single tile
+ *
+ * First the vertices are quantized onto a grid (LOD) to make them fit. A tile that still
+ * exceeds the limit is not built and returns the degradation signal instead (discarding it
+ * after building would stall the frame for exactly that long).
+ *
+ * The value was taken from measurements. Putting 8,172 administrative boundaries (about 1.1
+ * million vertices) through a single tile, building the index takes 0.8ms at z13, 1.2ms at
+ * z12, 4.0ms at z11, 15.6ms at z10 and 23.4ms at z9. 200,000 edges is roughly 20ms, and the
+ * only tiles that reach this amount are the coarse ones, of which there are just a few in the
+ * view (they are built only once, and after that the cache of the tile index takes over). The
+ * amount for the whole view is held down separately by the budget of the edge texture
+ * (DRAPE_MAX_EDGE_TEXELS in bin-store).
+ */
+export const DRAPE_MAX_EDGES_PER_TILE = 200000;
+/**
+ * The upper limit of the amount solved per cell (the average of runs + edges)
+ *
+ * A fragment walks the runs of its own cell in order and, for each run, sweeps the edges of
+ * that cell. The work per pixel is therefore roughly "the number of runs + the number of edges
+ * of that cell". When the map is zoomed far out, nested administrative areas (prefectures,
+ * districts, municipalities) and neighboring areas pile up dozens deep in a single cell and
+ * this amount jumps. In measurements it reached 500ms per frame over the whole Kanto region at
+ * z8.7.
+ *
+ * A tile that exceeds this is not suited to the analytic evaluation. The vertex displacement
+ * path takes it over (in a zoomed-out view the relief of the terrain is small on screen, so
+ * vertex displacement does not break down either).
+ *
+ * The actual limit is scaled up by the number of tiles in the view. The screen is shared out
+ * among the tiles, so the more tiles there are the fewer pixels each one has, and the same
+ * work per pixel costs less for the frame as a whole (`drapeCellWorkBudget`).
+ */
+export const DRAPE_MAX_CELL_WORK = 24;
+/**
+ * Derives the upper limit of the work per cell from the number of tiles in the view
+ */
+export function drapeCellWorkBudget(tileCount) {
+    const factor = Math.min(8, Math.max(1, tileCount / 4));
+    return DRAPE_MAX_CELL_WORK * factor;
+}
+/**
+ * The number of edges at which the vertices start being quantized onto a grid
+ *
+ * A tile below this solves the original geometry as it is (every view at a normal zoom is on
+ * this side, and quantization applies only to coarse distant tiles).
+ */
+export const DRAPE_LOD_TRIGGER = 16000;
+/** The resolution of the quantization grid (a single tile is stepped by 2^9 = 512) */
+const DRAPE_TILE_SAMPLES_LOG2 = 9;
+/**
+ * The lower bound of the quantization (a single tile is never made coarser than 2^8 = 256)
+ *
+ * A terrain tile is drawn at roughly 512 pixels on screen, so this step corresponds to 2
+ * pixels. Quantizing more coarsely than this makes polygons look like staircase-shaped blocks
+ * (verified in the field, the whole Kanto region at z8.7). A tile that does not fit even when
+ * made coarser is not suited to the analytic evaluation, so it is handed to the vertex
+ * displacement path.
+ */
+const DRAPE_MIN_SAMPLES_LOG2 = 8;
+/**
+ * The smallest size a terrain tile is assumed to occupy on screen (physical pixels)
+ *
+ * Outlines are drawn with a width in screen pixels, so even an edge outside a cell can paint
+ * pixels inside the cell. This is the conservative estimate used to convert that margin into
+ * in-tile coordinates (an actual tile is often drawn larger than this, and the margin comes out
+ * on the safe side by that much).
+ */
+const TILE_SCREEN_PX = 256;
+/**
+ * The lower and upper bounds of the margin (in-tile coordinates)
+ *
+ * Outlines are drawn with a width in screen pixels, so even an edge outside a cell can paint
+ * pixels inside the cell. The lower bound is the minimum needed to keep that from being missed
+ * (the drawn range fits inside the tile's [0, 1], so the margin is decided by the thickness of
+ * the outline alone).
+ */
+const MIN_MARGIN = 0.0025;
+// The upper bound is the size of the coarsest cell (1 / DRAPE_MIN_CELLS). A margin larger than
+// that would amount to "handing a single edge out to the whole tile", and only the index bloats
+const MAX_MARGIN = 1 / DRAPE_MIN_CELLS;
+/**
+ * Builds the key of the selection highlight
+ *
+ * So that IDs colliding across datasets are never mistaken for one another, the dataset
+ * ID and the feature ID are tied together with a delimiter. The side that builds the elements
+ * (`pass.ts`) and the side that collects the selection (`view/layer/drape-planner.ts`) use the
+ * same function.
+ */
+export function drapeSelectionKey(datasetId, featureId) {
+    return `${datasetId}\u0000${featureId}`;
+}
+/**
+ * The margin of an element (in-tile coordinates)
+ *
+ * A line is drawn with a thickness in screen pixels, so even an edge outside a cell paints
+ * pixels inside the cell. This is the margin used to hand that reach out to the cells. For an
+ * element that has a reference zoom the thickness changes by `2^(zoom - widthZoom)`, so the
+ * same factor is applied to the estimate as well. Forgetting to apply it eats the fringe of a
+ * thickened, zoomed-in line at the cell boundaries and chips it away into a jagged edge.
+ *
+ * @param strokeWidthPx The thickness at the reference zoom (physical pixels)
+ * @param widthZoom The reference zoom of the thickness (negative means fixed in screen pixels)
+ * @param zoom The current zoom
+ */
+export function drapeMarginOf(strokeWidthPx, widthZoom = -1, zoom = 0) {
+    const scale = widthZoom >= 0 ? 2 ** (zoom - widthZoom) : 1;
+    const half = strokeWidthPx * scale * 0.5 + 1;
+    return Math.min(MAX_MARGIN, Math.max(MIN_MARGIN, half / TILE_SCREEN_PX));
+}
+/**
+ * Decides the number of divisions of the grid (a power of two)
+ *
+ * From the number of edges it picks a resolution that fits within "the target number per cell",
+ * and holds it back to the range where a cell does not become smaller than the margin (if the
+ * margin were larger than a cell, a single edge would be scattered as far as the cell after
+ * the next one and only the index would bloat).
+ */
+export function chooseGrid(edgeCount, margin, elementCount = 0) {
+    let grid = DRAPE_MIN_CELLS;
+    const want = Math.max(Math.sqrt(Math.max(1, edgeCount) / DRAPE_TARGET_EDGES_PER_CELL), Math.sqrt(Math.max(1, elementCount) / DRAPE_TARGET_ELEMENTS_PER_CELL));
+    while (grid < DRAPE_MAX_CELLS && grid < want)
+        grid *= 2;
+    while (grid > DRAPE_MIN_CELLS && 1 / grid < margin)
+        grid /= 2;
+    return grid;
+}
+/**
+ * Performs the binning for a single tile
+ *
+ * @param elements The elements in draw order (the whole ordering. The index becomes the row of
+ *   the style)
+ * @param tile The tile
+ * @param candidates The indices of the elements narrowed down in advance (when omitted, every
+ *   element is looked at)
+ */
+export function binTile(elements, tile, options) {
+    const candidates = options?.candidates;
+    const maxCellWork = options?.maxCellWork ?? DRAPE_MAX_CELL_WORK;
+    const zoom = options?.zoom ?? 0;
+    const scale = 2 ** tile.z;
+    const floorLevel = tile.z + DRAPE_MIN_SAMPLES_LOG2;
+    // Pass 1: pick the relevant elements and estimate the amount of edges. If the amount is
+    // large, swap in geometry whose vertices have been quantized onto a grid (LOD) matching the
+    // resolution of that tile.
+    let quantizeLevel = 0;
+    let picked = pickElements(elements, candidates, tile, scale, quantizeLevel, zoom);
+    if (picked.edgeEstimate > DRAPE_LOD_TRIGGER) {
+        // Start from a grid that steps a single tile by roughly 512 and make it coarser one level
+        // at a time until it fits the budget. It must not skip ahead. The number of edges does not
+        // fall in proportion to the coarseness of the quantization; past a certain coarseness
+        // whole polygons collapse and it drops all at once. Skipping would pick a grid far coarser
+        // than necessary and polygons would look like square blocks (verified in the field, the
+        // whole Kanto region at z8.7)
+        for (quantizeLevel = tile.z + DRAPE_TILE_SAMPLES_LOG2; quantizeLevel >= floorLevel; quantizeLevel--) {
+            picked = pickElements(elements, candidates, tile, scale, quantizeLevel, zoom);
+            if (picked.edgeEstimate <= DRAPE_MAX_EDGES_PER_TILE)
+                break;
+        }
+        if (quantizeLevel < floorLevel)
+            quantizeLevel = floorLevel;
+    }
+    if (picked.edgeEstimate > DRAPE_MAX_EDGES_PER_TILE) {
+        // It does not fit even after quantization. Building alone takes hundreds of milliseconds,
+        // so it is degraded without being built
+        return emptyBins(DRAPE_MIN_CELLS, picked.edgeEstimate, true);
+    }
+    let grid = chooseGrid(picked.edgeEstimate, picked.maxMargin, picked.indices.length);
+    if (picked.indices.length === 0)
+        return emptyBins(grid, picked.edgeEstimate, false);
+    // Pass 2: actually build it. If cells that exceed the budget of a cell remain, those cells
+    // end up "solving inside/outside with too few edges" and show up as square blotches where a
+    // whole cell is painted. While truncation remains the grid is made finer, and if that is
+    // still not enough the quantization is made coarser and it is rebuilt. Only when there is
+    // nothing left to try does it return the degradation signal.
+    for (let attempt = 0; attempt < 10; attempt++) {
+        const bins = assembleBins(elements, picked, tile, scale, grid, zoom);
+        // A tile with too much work per pixel does not get any lighter whether the quantization is
+        // applied or the grid is made finer (the sheer number of deeply overlapping polygons is
+        // the cost). It is not suited to the analytic evaluation, so it returns the degradation
+        // signal as it is
+        if (bins.cellWork > maxCellWork)
+            return { ...bins, overflow: true };
+        if (bins.truncatedCells === 0)
+            return bins;
+        if (grid < DRAPE_RETRY_MAX_CELLS) {
+            grid *= 2;
+            continue;
+        }
+        if (quantizeLevel === 0) {
+            quantizeLevel = tile.z + DRAPE_TILE_SAMPLES_LOG2;
+        }
+        else if (quantizeLevel > floorLevel) {
+            quantizeLevel -= 1;
+        }
+        else {
+            return { ...bins, overflow: true };
+        }
+        picked = pickElements(elements, candidates, tile, scale, quantizeLevel, zoom);
+        // A grid that has once been made finer is never put back (putting it back would only
+        // repeat the work of making it finer)
+        grid = Math.max(grid, chooseGrid(picked.edgeEstimate, picked.maxMargin, picked.indices.length));
+    }
+    return emptyBins(DRAPE_MIN_CELLS, picked.edgeEstimate, true);
+}
+/** Empty bins (the common way to return for a degradation and for no relevant elements) */
+function emptyBins(grid, edgeEstimate, overflow) {
+    return {
+        grid,
+        cells: new Int32Array(grid * grid * 2),
+        runs: new Float32Array(0),
+        edges: new Float32Array(0),
+        overflow,
+        truncatedCells: 0,
+        cellWork: 0,
+        edgeEstimate,
+        maxEdgesPerCell: 0,
+        maxRunsPerCell: 0,
+    };
+}
+/**
+ * Actually builds the picked elements into the index with the grid that was decided
+ */
+function assembleBins(elements, picked, tile, scale, grid, zoom) {
+    const tileX = tile.x;
+    const tileY = tile.y;
+    const cellCount = grid * grid;
+    const cellSize = 1 / grid;
+    const cells = new Int32Array(cellCount * 2);
+    /** The edges in in-tile coordinates (four numbers per edge). Stacked across elements */
+    const edgeXY = [];
+    /** The runs per cell. Triples of (elementIndex, inside, edgeListIndex) laid out in a row */
+    const cellRuns = new Array(cellCount);
+    /** The lists of edge indices that the runs point to */
+    const runEdges = [];
+    /** The inside/outside difference per row (width grid + 1) */
+    const rowDiff = new Int8Array(grid * (grid + 1));
+    const rowTouched = new Uint8Array(grid);
+    const touchedRows = [];
+    /** The cell assignment for a single element */
+    const scratch = new Map();
+    /** The number of cells truncated for exceeding the budget */
+    let truncatedCells = 0;
+    /** The diagnostic values */
+    let maxEdgesPerCell = 0;
+    let maxRunsPerCell = 0;
+    const pushRun = (cell, elementIndex, inside, list) => {
+        let target = cellRuns[cell];
+        if (!target) {
+            target = [];
+            cellRuns[cell] = target;
+        }
+        let edgeListIndex = -1;
+        if (list !== undefined && list.length > 0) {
+            edgeListIndex = runEdges.length;
+            runEdges.push(list);
+        }
+        target.push(elementIndex, inside, edgeListIndex);
+    };
+    for (let p = 0; p < picked.indices.length; p++) {
+        const index = picked.indices[p];
+        const element = elements[index];
+        const margin = drapeMarginOf(element.strokeWidthPx, element.widthZoom, zoom);
+        scratch.clear();
+        touchedRows.length = 0;
+        rowTouched.fill(0);
+        for (const path of picked.geometries[p].paths) {
+            scanPath(path, element.kind, tileX, tileY, scale, margin, grid, cellSize, edgeXY, scratch, rowDiff, rowTouched, touchedRows);
+        }
+        // Turn the cells that are inside and the cells the edges touch into runs (they are stacked
+        // in the order of the elements, so this comes out as the draw order)
+        const emitted = new Set();
+        for (const row of touchedRows) {
+            const base = row * (grid + 1);
+            let inside = 0;
+            for (let i = 0; i < grid; i++) {
+                inside ^= rowDiff[base + i];
+                const cell = row * grid + i;
+                const list = scratch.get(cell);
+                if (inside === 0 && list === undefined)
+                    continue;
+                emitted.add(cell);
+                pushRun(cell, index, inside, list);
+            }
+            rowDiff.fill(0, base, base + grid + 1);
+        }
+        for (const [cell, list] of scratch) {
+            if (emitted.has(cell))
+                continue;
+            pushRun(cell, index, 0, list);
+        }
+    }
+    // Repacking (laid out in the order cell -> run -> edge)
+    const runs = [];
+    const edges = [];
+    for (let c = 0; c < cellCount; c++) {
+        const list = cellRuns[c];
+        cells[c * 2] = runs.length / 4;
+        if (!list) {
+            cells[c * 2 + 1] = 0;
+            continue;
+        }
+        let runCount = 0;
+        let truncated = false;
+        for (let i = 0; i + 2 < list.length; i += 3) {
+            if (runCount >= DRAPE_MAX_RUNS_PER_CELL) {
+                truncated = true;
+                break;
+            }
+            const edgeListIndex = list[i + 2];
+            const edgeStart = edges.length / 4;
+            let edgeCount = 0;
+            if (edgeListIndex >= 0) {
+                for (const at of runEdges[edgeListIndex]) {
+                    if (edgeCount >= DRAPE_MAX_EDGES_PER_CELL) {
+                        truncated = true;
+                        break;
+                    }
+                    edges.push(edgeXY[at * 4], edgeXY[at * 4 + 1], edgeXY[at * 4 + 2], edgeXY[at * 4 + 3]);
+                    edgeCount++;
+                }
+            }
+            runs.push(list[i], edgeStart, edgeCount, list[i + 1]);
+            runCount++;
+            if (edgeCount > maxEdgesPerCell)
+                maxEdgesPerCell = edgeCount;
+        }
+        if (truncated)
+            truncatedCells++;
+        if (runCount > maxRunsPerCell)
+            maxRunsPerCell = runCount;
+        cells[c * 2 + 1] = runCount;
+    }
+    return {
+        grid,
+        cells,
+        runs: new Float32Array(runs),
+        edges: new Float32Array(edges),
+        overflow: false,
+        truncatedCells,
+        cellWork: (runs.length / 4 + edges.length / 4) / cellCount,
+        edgeEstimate: picked.edgeEstimate,
+        maxEdgesPerCell,
+        maxRunsPerCell,
+    };
+}
+/**
+ * Picks the elements relevant to a tile by their bounding box
+ *
+ * @param quantizeLevel 0 uses the original geometry, anything else uses the geometry quantized
+ *   to that resolution
+ */
+function pickElements(elements, candidates, tile, scale, quantizeLevel, zoom) {
+    const indices = [];
+    const geometries = [];
+    let edgeEstimate = 0;
+    let maxMargin = MIN_MARGIN;
+    // Quantization can move a vertex outward by half a step of the grid, so it is added to the
+    // margin used for the selection
+    const quantizeSlack = quantizeLevel > 0 ? 2 ** -quantizeLevel : 0;
+    const length = candidates ? candidates.length : elements.length;
+    for (let n = 0; n < length; n++) {
+        const index = candidates ? candidates[n] : n;
+        const element = elements[index];
+        const margin = drapeMarginOf(element.strokeWidthPx, element.widthZoom, zoom);
+        const m = margin / scale + quantizeSlack;
+        const box = element.bounds;
+        if (box.maxX < tile.x / scale - m ||
+            box.minX > (tile.x + 1) / scale + m ||
+            box.maxY < tile.y / scale - m ||
+            box.minY > (tile.y + 1) / scale + m) {
+            continue;
+        }
+        // This is where the coordinates are converted for the first time (only the features that
+        // touch the view)
+        const base = element.geometry();
+        if (base.edgeCount === 0)
+            continue;
+        const geometry = quantizeLevel > 0 ? drapeQuantizedGeometry(base, quantizeLevel) : base;
+        if (geometry.edgeCount === 0)
+            continue;
+        indices.push(index);
+        geometries.push(geometry);
+        if (margin > maxMargin)
+            maxMargin = margin;
+        edgeEstimate += countNearEdges(geometry, tile.x, tile.y, scale, m);
+    }
+    return { indices, geometries, edgeEstimate, maxMargin };
+}
+/**
+ * Streams a single path into the grid of the tile
+ *
+ * A polygon does two jobs at once. One is the assignment of edges to cells, the other is the
+ * tallying of "the inside/outside of the cell origin". The latter counts the crossings to the
+ * right of the origin, so an edge outside the tile on the right also counts (it becomes a flip
+ * of a whole row). An edge outside on the left flips nothing, so it can be dropped.
+ */
+function scanPath(path, kind, tileX, tileY, scale, margin, grid, cellSize, edgeXY, scratch, rowDiff, rowTouched, touchedRows) {
+    const xy = path.xy;
+    const vertexCount = xy.length / 2;
+    const blockCount = path.blocks.length / 4;
+    for (let b = 0; b < blockCount; b++) {
+        const by0 = path.blocks[b * 4 + 1] * scale - tileY;
+        const by1 = path.blocks[b * 4 + 3] * scale - tileY;
+        if (by1 < -margin || by0 > 1 + margin)
+            continue;
+        const bx0 = path.blocks[b * 4] * scale - tileX;
+        const bx1 = path.blocks[b * 4 + 2] * scale - tileX;
+        if (bx1 < -margin)
+            continue;
+        if (kind === 1 && bx0 > 1 + margin)
+            continue;
+        const from = b * DRAPE_BLOCK_EDGES;
+        const to = Math.min(path.edgeCount, from + DRAPE_BLOCK_EDGES);
+        for (let e = from; e < to; e++) {
+            const v1 = e + 1 < vertexCount ? e + 1 : 0;
+            const x0 = xy[e * 2] * scale - tileX;
+            const y0 = xy[e * 2 + 1] * scale - tileY;
+            const x1 = xy[v1 * 2] * scale - tileX;
+            const y1 = xy[v1 * 2 + 1] * scale - tileY;
+            if (x0 === x1 && y0 === y1)
+                continue;
+            if (kind === 0) {
+                accumulateInside(x0, y0, x1, y1, grid, cellSize, rowDiff, rowTouched, touchedRows);
+            }
+            scatterEdge(x0, y0, x1, y1, margin, grid, cellSize, edgeXY, scratch);
+        }
+    }
+}
+/**
+ * Adds "the crossings to the right of the cell origin" for a single edge to the row difference
+ *
+ * Every cell whose origin lies to the left of the crossing point xint is flipped. The range
+ * that is flipped is [0, k), so by setting 0 and k in the difference array and afterwards
+ * taking the exclusive OR from the left in order, the inside/outside of the whole row comes
+ * out.
+ */
+function accumulateInside(x0, y0, x1, y1, grid, cellSize, rowDiff, rowTouched, touchedRows) {
+    if (y0 === y1)
+        return;
+    const yLo = Math.min(y0, y1);
+    const yHi = Math.max(y0, y1);
+    let jLo = Math.ceil(yLo / cellSize);
+    let jHi = Math.floor(yHi / cellSize);
+    if (jLo < 0)
+        jLo = 0;
+    if (jHi > grid - 1)
+        jHi = grid - 1;
+    if (jLo > jHi)
+        return;
+    const inv = 1 / (y1 - y0);
+    for (let j = jLo; j <= jHi; j++) {
+        const yj = j * cellSize;
+        if (y0 > yj === y1 > yj)
+            continue;
+        const t = (yj - y0) * inv;
+        const xint = x0 + t * (x1 - x0);
+        let k = Math.ceil(xint / cellSize);
+        if (k <= 0)
+            continue;
+        if (k > grid)
+            k = grid;
+        const base = j * (grid + 1);
+        if (rowTouched[j] === 0) {
+            rowTouched[j] = 1;
+            touchedRows.push(j);
+        }
+        rowDiff[base] ^= 1;
+        rowDiff[base + k] ^= 1;
+    }
+}
+/**
+ * Assigns a single edge to the cells it passes through (including the margin)
+ *
+ * Sweeping the bounding box as it is would touch a whole rectangle of cells for a single edge
+ * that crosses the tile diagonally. The segment is cut per row to obtain the range of x, and
+ * only the columns in that range are touched.
+ */
+function scatterEdge(x0, y0, x1, y1, margin, grid, cellSize, edgeXY, scratch) {
+    const exLo = Math.min(x0, x1) - margin;
+    const exHi = Math.max(x0, x1) + margin;
+    const eyLo = Math.min(y0, y1) - margin;
+    const eyHi = Math.max(y0, y1) + margin;
+    if (exHi < 0 || exLo > 1 || eyHi < 0 || eyLo > 1)
+        return;
+    let jLo = Math.floor(eyLo / cellSize);
+    let jHi = Math.floor(eyHi / cellSize);
+    if (jLo < 0)
+        jLo = 0;
+    if (jHi > grid - 1)
+        jHi = grid - 1;
+    if (jLo > jHi)
+        return;
+    const at = edgeXY.length / 4;
+    edgeXY.push(x0, y0, x1, y1);
+    const horizontal = y0 === y1;
+    const inv = horizontal ? 0 : 1 / (y1 - y0);
+    for (let j = jLo; j <= jHi; j++) {
+        let xa;
+        let xb;
+        if (horizontal) {
+            xa = Math.min(x0, x1);
+            xb = Math.max(x0, x1);
+        }
+        else {
+            let t0 = (j * cellSize - margin - y0) * inv;
+            let t1 = ((j + 1) * cellSize + margin - y0) * inv;
+            if (t0 > t1) {
+                const swap = t0;
+                t0 = t1;
+                t1 = swap;
+            }
+            if (t0 < 0)
+                t0 = 0;
+            if (t1 > 1)
+                t1 = 1;
+            if (t0 > t1)
+                continue;
+            const xt0 = x0 + t0 * (x1 - x0);
+            const xt1 = x0 + t1 * (x1 - x0);
+            xa = Math.min(xt0, xt1);
+            xb = Math.max(xt0, xt1);
+        }
+        xa -= margin;
+        xb += margin;
+        if (xb < 0 || xa > 1)
+            continue;
+        let iLo = Math.floor(xa / cellSize);
+        let iHi = Math.floor(xb / cellSize);
+        if (iLo < 0)
+            iLo = 0;
+        if (iHi > grid - 1)
+            iHi = grid - 1;
+        for (let i = iLo; i <= iHi; i++) {
+            const cell = j * grid + i;
+            const list = scratch.get(cell);
+            // No limit is applied here. Applying one would create "a cell that silently lost edges",
+            // the inside/outside test would go wrong and a whole cell would be painted. Truncation
+            // is detected during the repacking
+            if (list)
+                list.push(at);
+            else
+                scratch.set(cell, [at]);
+        }
+    }
+}
+/**
+ * Counts the number of edges near the tile (an estimate for deciding the resolution of the grid)
+ */
+function countNearEdges(geometry, tileX, tileY, scale, margin) {
+    const x0 = tileX / scale - margin;
+    const y0 = tileY / scale - margin;
+    const x1 = (tileX + 1) / scale + margin;
+    const y1 = (tileY + 1) / scale + margin;
+    let count = 0;
+    for (const path of geometry.paths) {
+        const blockCount = path.blocks.length / 4;
+        for (let b = 0; b < blockCount; b++) {
+            if (path.blocks[b * 4 + 2] < x0 ||
+                path.blocks[b * 4] > x1 ||
+                path.blocks[b * 4 + 3] < y0 ||
+                path.blocks[b * 4 + 1] > y1) {
+                continue;
+            }
+            count += Math.min(DRAPE_BLOCK_EDGES, path.edgeCount - b * DRAPE_BLOCK_EDGES);
+        }
+    }
+    return count;
+}

package/dist/view/terrain/drape/edge-constrain.d.ts

@@ -0,0 +1,37 @@
+import type { DrapeTerrainTexture, UniformSet } from './shared.js';
+import type { ResolvedTileEdges } from './stitch.js';
+/** The order of the edges (used to assemble the uniform names) */
+export declare const EDGE_NAMES: readonly ["top", "bottom", "left", "right"];
+export type EdgeName = (typeof EDGE_NAMES)[number];
+/**
+ * The DEM texture unit per edge (one's own DEM is unit 0)
+ *
+ * 6 is not used. The DEM atlas (TERRAIN_ATLAS_TEXTURE_UNIT in state.ts) is bound to 6 at the
+ * head of the frame and stays there, and every renderer of the vertex displacement path reads
+ * it as u_dem_atlas as is. Overwriting it here would make whatever is drawn after the drape
+ * rendering (a preview being drawn, dashed lines and so on) look elevations up in a broken
+ * texture and fly off screen. 1 to 4 are used by the data textures (renderer.ts) and the
+ * contents of the quads (quad.ts).
+ */
+export declare const EDGE_UNITS: Record<EdgeName, number>;
+/**
+ * The GLSL of the edge constraint (injected into the vertex shader)
+ *
+ * It goes after TERRAIN_SAMPLE_GLSL (because it uses u_terrain_exaggeration and the upstream DEM
+ * functions it carries). The caller
+ * obtains the constrained elevation with `drape_edge_constrained(a_pos, ele)`.
+ */
+export declare const EDGE_CONSTRAIN_GLSL: string;
+/** The names of the uniforms the edge constraint uses (for getUniformLocation) */
+export declare const EDGE_CONSTRAIN_UNIFORMS: readonly string[];
+/**
+ * Writes the uniforms of the edge constraint
+ *
+ * The step and the DEM are both written from one and the same value (the result of
+ * resolveTileEdges). They all come out of the terrain tile state at one and the same instant,
+ * so the inconsistency "the DEM is new but the step is old" cannot occur. An edge with no
+ * coarse neighbor (an edge that is not constrained) gets one's own DEM at unit scale with a
+ * translation of 0. It is never referenced because the step is 0, but leaving an unbound
+ * sampler makes the rendering itself fail in some implementations.
+ */
+export declare function applyEdgeConstrainUniforms(gl: WebGL2RenderingContext, set: UniformSet, edges: ResolvedTileEdges<DrapeTerrainTexture>, own: DrapeTerrainTexture): void;