@sakuzu/maplibre-gl-draw 2.1.0 → 2.1.1

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

@@ -1,6 +1,6 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
-import { DRAPE_BLOCK_EDGES, drapeQuantizedGeometry } from './geometry.js';
+import { DRAPE_BLOCK_EDGES, drapePathStarts, 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) */
@@ -245,6 +245,7 @@ function emptyBins(grid, edgeEstimate, overflow) {
         cells: new Int32Array(grid * grid * 2),
         runs: new Float32Array(0),
         edges: new Float32Array(0),
+        edgeStarts: new Float32Array(0),
         overflow,
         truncatedCells: 0,
         cellWork: 0,
@@ -264,6 +265,8 @@ function assembleBins(elements, picked, tile, scale, grid, zoom) {
     const cells = new Int32Array(cellCount * 2);
     /** The edges in in-tile coordinates (four numbers per edge). Stacked across elements */
     const edgeXY = [];
+    /** Where each edge starts along its path (one number per edge) */
+    const edgeS = [];
     /** 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 */
@@ -299,8 +302,9 @@ function assembleBins(elements, picked, tile, scale, grid, zoom) {
         scratch.clear();
         touchedRows.length = 0;
         rowTouched.fill(0);
+        const dashed = element.dash != null;
         for (const path of picked.geometries[p].paths) {
-            scanPath(path, element.kind, tileX, tileY, scale, margin, grid, cellSize, edgeXY, scratch, rowDiff, rowTouched, touchedRows);
+            scanPath(path, element.kind, tileX, tileY, scale, margin, grid, cellSize, { xy: edgeXY, starts: edgeS }, dashed ? drapePathStarts(path) : null, 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)
@@ -328,6 +332,7 @@ function assembleBins(elements, picked, tile, scale, grid, zoom) {
     // Repacking (laid out in the order cell -> run -> edge)
     const runs = [];
     const edges = [];
+    const edgeStarts = [];
     for (let c = 0; c < cellCount; c++) {
         const list = cellRuns[c];
         cells[c * 2] = runs.length / 4;
@@ -352,6 +357,7 @@ function assembleBins(elements, picked, tile, scale, grid, zoom) {
                         break;
                     }
                     edges.push(edgeXY[at * 4], edgeXY[at * 4 + 1], edgeXY[at * 4 + 2], edgeXY[at * 4 + 3]);
+                    edgeStarts.push(edgeS[at]);
                     edgeCount++;
                 }
             }
@@ -371,6 +377,7 @@ function assembleBins(elements, picked, tile, scale, grid, zoom) {
         cells,
         runs: new Float32Array(runs),
         edges: new Float32Array(edges),
+        edgeStarts: new Float32Array(edgeStarts),
         overflow: false,
         truncatedCells,
         cellWork: (runs.length / 4 + edges.length / 4) / cellCount,
@@ -430,7 +437,7 @@ function pickElements(elements, candidates, tile, scale, quantizeLevel, zoom) {
  * 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) {
+function scanPath(path, kind, tileX, tileY, scale, margin, grid, cellSize, out, starts, scratch, rowDiff, rowTouched, touchedRows) {
     const xy = path.xy;
     const vertexCount = xy.length / 2;
     const blockCount = path.blocks.length / 4;
@@ -458,7 +465,7 @@ function scanPath(path, kind, tileX, tileY, scale, margin, grid, cellSize, edgeX
             if (kind === 0) {
                 accumulateInside(x0, y0, x1, y1, grid, cellSize, rowDiff, rowTouched, touchedRows);
             }
-            scatterEdge(x0, y0, x1, y1, margin, grid, cellSize, edgeXY, scratch);
+            scatterEdge(x0, y0, x1, y1, starts ? starts[e] : 0, margin, grid, cellSize, out, scratch);
         }
     }
 }
@@ -511,7 +518,7 @@ function accumulateInside(x0, y0, x1, y1, grid, cellSize, rowDiff, rowTouched, t
  * 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) {
+function scatterEdge(x0, y0, x1, y1, start, margin, grid, cellSize, out, scratch) {
     const exLo = Math.min(x0, x1) - margin;
     const exHi = Math.max(x0, x1) + margin;
     const eyLo = Math.min(y0, y1) - margin;
@@ -526,8 +533,9 @@ function scatterEdge(x0, y0, x1, y1, margin, grid, cellSize, edgeXY, scratch) {
         jHi = grid - 1;
     if (jLo > jHi)
         return;
-    const at = edgeXY.length / 4;
-    edgeXY.push(x0, y0, x1, y1);
+    const at = out.starts.length;
+    out.xy.push(x0, y0, x1, y1);
+    out.starts.push(start);
     const horizontal = y0 === y1;
     const inv = horizontal ? 0 : 1 / (y1 - y0);
     for (let j = jLo; j <= jHi; j++) {

package/dist/view/terrain/drape/geometry.d.ts

@@ -29,6 +29,20 @@ export interface DrapeGeometryPath {
     readonly closed: boolean;
     /** The bounding box of each block (minX, minY, maxX, maxY) */
     readonly blocks: Float64Array;
+    /**
+     * Where the vertices of a quantized path came from (absent on a path of the original
+     * geometry)
+     *
+     * A dashed line keeps the pattern of the original path on a coarse tile: the length along
+     * the path at a vertex is that of the original vertex it was rounded from
+     * ({@link drapePathStarts}).
+     */
+    readonly origin?: DrapePathOrigin;
+}
+/** The original path of a quantized path, and the original vertex of each of its vertices */
+export interface DrapePathOrigin {
+    readonly path: DrapeGeometryPath;
+    readonly vertices: Int32Array;
 }
 /** The geometry of a single feature */
 export interface DrapeGeometry {
@@ -93,3 +107,16 @@ export declare function buildDrapeGeometry(paths: ReadonlyArray<ReadonlyArray<Co
  * @param level The fineness of the grid. The grid spacing is 2^-level (in Mercator units)
  */
 export declare function drapeQuantizedGeometry(geometry: DrapeGeometry, level: number): DrapeGeometry;
+/**
+ * The length along a path from its first vertex to each of its vertices (Mercator units)
+ *
+ * Entry `e` is where edge `e` starts on the path, so a dashed line can place its pattern on
+ * every edge on its own (on a closed path the last edge, back to the first vertex, starts at
+ * the last vertex). It is built only for dashed lines and polygons with a dashed outline, the
+ * first time a tile needs it, so a solid line pays nothing for it.
+ *
+ * A quantized path takes the lengths of the original vertices it was rounded from, so the
+ * pattern on a coarse tile stays in step with the pattern on the fine tiles next to it. A
+ * square standing in for a collapsed polygon has no original and measures itself.
+ */
+export declare function drapePathStarts(path: DrapeGeometryPath): Float64Array;

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

@@ -103,15 +103,18 @@ export function buildDrapeGeometry(paths, closed) {
 }
 /**
  * Assembles the geometry from paths in Mercator coordinates
+ *
+ * @param origins The origin of each path, for quantized geometry (null for a path that has none)
  */
-function buildFromMercatorPaths(paths, closed) {
+function buildFromMercatorPaths(paths, closed, origins) {
     const out = [];
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
     let maxY = Number.NEGATIVE_INFINITY;
     let edgeCount = 0;
-    for (const xy of paths) {
+    for (let p = 0; p < paths.length; p++) {
+        const xy = paths[p];
         const count = xy.length / 2;
         if (count < 2)
             continue;
@@ -156,7 +159,10 @@ function buildFromMercatorPaths(paths, closed) {
             blocks[b * 4 + 2] = bx1;
             blocks[b * 4 + 3] = by1;
         }
-        out.push({ xy, edgeCount: edges, closed, blocks });
+        const origin = origins?.[p];
+        out.push(origin
+            ? { xy, edgeCount: edges, closed, blocks, origin }
+            : { xy, edgeCount: edges, closed, blocks });
         edgeCount += edges;
     }
     if (out.length === 0) {
@@ -193,10 +199,13 @@ export function drapeQuantizedGeometry(geometry, level) {
         return hit;
     const step = 2 ** -level;
     const paths = [];
+    const origins = [];
     for (const path of geometry.paths) {
         const source = path.xy;
         const count = source.length / 2;
         const out = [];
+        /** The original vertex of each vertex kept */
+        const kept = [];
         let lastX = Number.NaN;
         let lastY = Number.NaN;
         for (let i = 0; i < count; i++) {
@@ -205,6 +214,7 @@ export function drapeQuantizedGeometry(geometry, level) {
             if (qx === lastX && qy === lastY)
                 continue;
             out.push(qx, qy);
+            kept.push(i);
             lastX = qx;
             lastY = qy;
         }
@@ -213,16 +223,20 @@ export function drapeQuantizedGeometry(geometry, level) {
             // dropped
             while (out.length >= 6 && out[out.length - 2] === out[0] && out[out.length - 1] === out[1]) {
                 out.length -= 2;
+                kept.length -= 1;
             }
             if (out.length / 2 < 3) {
                 // A polygon collapsed by the rounding is replaced with a square of one grid cell.
                 // Dropping it would leave the fill missing just there and produce spotty white
                 // blotches (confirmed hands-on, the city center at z8.7; it was pronounced in areas
                 // where small polygons at the chome level line up).
-                // The error stays within one grid cell (1/256 of a tile = about 2 pixels on screen)
+                // The error stays within one grid cell (1/256 of a tile = about 2 pixels on screen).
+                // It has no origin: a dash pattern on it would be smaller than a pixel anyway
                 const box = squareAt(source, step);
-                if (box)
+                if (box) {
                     paths.push(box);
+                    origins.push(null);
+                }
                 continue;
             }
         }
@@ -230,8 +244,9 @@ export function drapeQuantizedGeometry(geometry, level) {
             continue;
         }
         paths.push(new Float64Array(out));
+        origins.push({ path, vertices: new Int32Array(kept) });
     }
-    const built = buildFromMercatorPaths(paths, geometry.paths[0]?.closed ?? true);
+    const built = buildFromMercatorPaths(paths, geometry.paths[0]?.closed ?? true, origins);
     cache.set(level, built);
     return built;
 }
@@ -258,3 +273,39 @@ function squareAt(source, step) {
     const cy = Math.round(sy / count / step) * step;
     return new Float64Array([cx, cy, cx + step, cy, cx + step, cy + step, cx, cy + step]);
 }
+/** The lengths along the paths (path -> the length at each vertex) */
+const startsCache = new WeakMap();
+/**
+ * The length along a path from its first vertex to each of its vertices (Mercator units)
+ *
+ * Entry `e` is where edge `e` starts on the path, so a dashed line can place its pattern on
+ * every edge on its own (on a closed path the last edge, back to the first vertex, starts at
+ * the last vertex). It is built only for dashed lines and polygons with a dashed outline, the
+ * first time a tile needs it, so a solid line pays nothing for it.
+ *
+ * A quantized path takes the lengths of the original vertices it was rounded from, so the
+ * pattern on a coarse tile stays in step with the pattern on the fine tiles next to it. A
+ * square standing in for a collapsed polygon has no original and measures itself.
+ */
+export function drapePathStarts(path) {
+    const hit = startsCache.get(path);
+    if (hit)
+        return hit;
+    const count = path.xy.length / 2;
+    const starts = new Float64Array(count);
+    if (path.origin) {
+        const original = drapePathStarts(path.origin.path);
+        for (let i = 0; i < count; i++)
+            starts[i] = original[path.origin.vertices[i]];
+    }
+    else {
+        const xy = path.xy;
+        let total = 0;
+        for (let i = 1; i < count; i++) {
+            total += Math.hypot(xy[i * 2] - xy[i * 2 - 2], xy[i * 2 + 1] - xy[i * 2 - 1]);
+            starts[i] = total;
+        }
+    }
+    startsCache.set(path, starts);
+    return starts;
+}

package/dist/view/terrain/drape/pass.d.ts

@@ -25,8 +25,8 @@ export declare const DRAPE_MAX_VERTICES = 4000000;
 export interface DrapeCollectResult {
     /** The elements in draw order */
     readonly elements: DrapeElement[];
-    /** The IDs of the Store features that cannot be put on the drape (points, images, dashed
-     * lines and so on) */
+    /** The IDs of the Store features that cannot be put on the drape (points, images and so
+     * on) */
     readonly excluded: Set<string>;
     /** The breaks in the stacking order (the positions of the images; dataset order =
      * ascending afterElements) */
@@ -98,8 +98,13 @@ export interface DrapeDatasetSource {
  * It is not narrowed down by the view. Narrowing it down would change the element order every
  * time the view moves and require rebuilding the tile indices (the narrowing down within a
  * tile is done by `binTile` using the bounding boxes).
+ *
+ * @param pixelRatio The rendering pixel ratio, for widths fixed in screen pixels (the rendering
+ *   scale included; `resolvePixelRatio`)
+ * @param contentPixelRatio The rendering pixel ratio for widths that follow the zoom (the
+ *   rendering scale not applied; `resolveContentPixelRatio`)
  */
-export declare function collectDrapeElements(store: Store, styles: RetainedStyleResolver, pixelRatio: number, datasets: readonly DrapeDatasetSource[]): DrapeCollectResult;
+export declare function collectDrapeElements(store: Store, styles: RetainedStyleResolver, pixelRatio: number, contentPixelRatio: number, datasets: readonly DrapeDatasetSource[]): DrapeCollectResult;
 /**
  * Whether the analytic drape may be used
  *

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

@@ -20,6 +20,7 @@ import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { getCreatedZoom } from '../../../shared/utils/property.js';
 import { getDisplayFeatures, isLocallyHidden } from '../../../store/local-visibility.js';
 import { layerDrawFactors } from '../../renderers/draw-factors.js';
+import { dashCoefficientsOf } from '../../renderers/line/dash.js';
 import { drapeSelectionKey, } from './binning.js';
 import { drapeBoundsOf, drapeGeometryOf } from './geometry.js';
 import { DRAPE_MAX_SOURCES } from './renderer.js';
@@ -74,8 +75,13 @@ export function drapeLayerSource(layerIndex, datasetCount) {
  * It is not narrowed down by the view. Narrowing it down would change the element order every
  * time the view moves and require rebuilding the tile indices (the narrowing down within a
  * tile is done by `binTile` using the bounding boxes).
+ *
+ * @param pixelRatio The rendering pixel ratio, for widths fixed in screen pixels (the rendering
+ *   scale included; `resolvePixelRatio`)
+ * @param contentPixelRatio The rendering pixel ratio for widths that follow the zoom (the
+ *   rendering scale not applied; `resolveContentPixelRatio`)
  */
-export function collectDrapeElements(store, styles, pixelRatio, datasets) {
+export function collectDrapeElements(store, styles, pixelRatio, contentPixelRatio, datasets) {
     const visible = getDisplayFeatures(store);
     const byLayer = new Map();
     for (const feature of visible) {
@@ -97,6 +103,7 @@ export function collectDrapeElements(store, styles, pixelRatio, datasets) {
         drapedDatasets: new Set(),
         styles,
         pixelRatio,
+        contentPixelRatio,
         layerSources: new Map(),
     };
     const byId = new Map();
@@ -168,21 +175,13 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
     }
     if (feature.type === 'Polygon' || feature.type === 'MultiPolygon') {
         const { fillColor, strokeStyle } = context.styles.getPolygonStyles(feature, layer);
-        // Dashed lines are not put through the analytic evaluation (solving the accumulated
-        // distance along the outline from the pixel is not implemented). Drawing them as solid
-        // lines would change the appearance, so features with dashed lines are routed to the
-        // previous vertex displacement path.
-        if (strokeStyle.lineStyle !== 'solid') {
-            context.excluded.add(feature.id);
-            return;
-        }
         const hasStroke = strokeStyle.opacity > 0 && strokeStyle.width > 0;
         const rings = polygonRings(feature);
         if (rings.length === 0)
             return;
         if (fillColor[3] <= 0 && !hasStroke)
             return;
-        const polygonWidth = widthOf(feature, strokeStyle.width, context.pixelRatio);
+        const polygonWidth = widthOf(feature, strokeStyle.width, context);
         pushElement(context, feature, 0, rings, {
             fill: [fillColor[0], fillColor[1], fillColor[2], fillColor[3] * bakedOpacity],
             stroke: [
@@ -192,6 +191,7 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
                 strokeStyle.color[3] * (hasStroke ? strokeStyle.opacity : 0) * bakedOpacity,
             ],
             strokeWidthPx: hasStroke ? polygonWidth.px : 0,
+            dash: dashOf(strokeStyle.lineStyle, polygonWidth),
             source,
             widthZoom: polygonWidth.zoom,
             // A Store selection is expressed by the selection UI (the box and the handles). The
@@ -201,16 +201,12 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
         return;
     }
     const strokeStyle = context.styles.getLineStringStrokeStyle(feature, layer);
-    if (strokeStyle.lineStyle !== 'solid') {
-        context.excluded.add(feature.id);
-        return;
-    }
     if (strokeStyle.opacity <= 0 || strokeStyle.width <= 0)
         return;
     const paths = linePaths(feature);
     if (paths.length === 0)
         return;
-    const lineWidth = widthOf(feature, strokeStyle.width, context.pixelRatio);
+    const lineWidth = widthOf(feature, strokeStyle.width, context);
     pushElement(context, feature, 1, paths, {
         fill: [0, 0, 0, 0],
         stroke: [
@@ -220,6 +216,7 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
             strokeStyle.color[3] * strokeStyle.opacity * bakedOpacity,
         ],
         strokeWidthPx: lineWidth.px,
+        dash: dashOf(strokeStyle.lineStyle, lineWidth),
         source,
         widthZoom: lineWidth.zoom,
         selectionKey: '',
@@ -243,16 +240,12 @@ function collectDataset(context, dataset, source) {
         if (feature.type === 'Polygon' || feature.type === 'MultiPolygon') {
             const { fillColor, strokeStyle } = context.styles.getPolygonStyles(feature);
             const hasStroke = strokeStyle.opacity > 0 && strokeStyle.width > 0;
-            // A dashed outline is drawn by the immediate path on the retained batch side (the
-            // paired test)
-            if (hasStroke && strokeStyle.lineStyle !== 'solid')
-                continue;
             if (!hasStroke && fillColor[3] <= 0)
                 continue;
             const rings = polygonRings(feature);
             if (rings.length === 0)
                 continue;
-            const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
+            const width = widthOf(feature, strokeStyle.width, context);
             pushElement(context, coordinatesOf(feature), 0, rings, {
                 fill: fillColor,
                 stroke: [
@@ -262,6 +255,7 @@ function collectDataset(context, dataset, source) {
                     hasStroke ? strokeStyle.color[3] : 0,
                 ],
                 strokeWidthPx: hasStroke ? width.px : 0,
+                dash: dashOf(strokeStyle.lineStyle, width),
                 source,
                 widthZoom: width.zoom,
                 selectionKey: drapeSelectionKey(dataset.id, feature.id),
@@ -274,14 +268,12 @@ function collectDataset(context, dataset, source) {
             continue;
         }
         const strokeStyle = context.styles.getLineStringStrokeStyle(feature);
-        if (strokeStyle.lineStyle !== 'solid')
-            continue;
         if (strokeStyle.opacity <= 0 || strokeStyle.width <= 0)
             continue;
         const paths = linePaths(feature);
         if (paths.length === 0)
             continue;
-        const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
+        const width = widthOf(feature, strokeStyle.width, context);
         pushElement(context, coordinatesOf(feature), 1, paths, {
             fill: [0, 0, 0, 0],
             stroke: [
@@ -291,6 +283,7 @@ function collectDataset(context, dataset, source) {
                 strokeStyle.color[3] * strokeStyle.opacity,
             ],
             strokeWidthPx: width.px,
+            dash: dashOf(strokeStyle.lineStyle, width),
             source,
             widthZoom: width.zoom,
             selectionKey: drapeSelectionKey(dataset.id, feature.id),
@@ -301,15 +294,31 @@ function collectDataset(context, dataset, source) {
  * Resolves the line width with the same convention as the retained batch path
  *
  * A feature without a `createdZoom` is fixed in screen pixels (the rendering scale applies),
- * and a feature with one scales by `2^(zoom - createdZoom)`. So that the thickness does not
- * change with the presence of terrain, the drape follows the same convention.
+ * and a feature with one scales by `2^(zoom - createdZoom)` (the device pixel ratio applies,
+ * the rendering scale does not). So that the thickness does not change with the presence of
+ * terrain, the drape follows the same convention.
  */
-function widthOf(feature, width, pixelRatio) {
+function widthOf(feature, width, ratios) {
     const createdZoom = getCreatedZoom(feature);
     if (createdZoom !== undefined && Number.isFinite(createdZoom)) {
-        return { px: width, zoom: createdZoom };
+        const ratio = ratios.contentPixelRatio;
+        return { px: width * ratio, zoom: createdZoom, ratio };
     }
-    return { px: width * pixelRatio, zoom: -1 };
+    return { px: width * ratios.pixelRatio, zoom: -1, ratio: ratios.pixelRatio };
+}
+/**
+ * The dash pattern of an outline, or null for a solid one
+ *
+ * The coefficients come from the table the subdividing path uses (`dash.ts`), and the
+ * shader turns them into the dash and the gap of the width the line has in the frame, in
+ * CSS pixels as the subdividing path measures them: the pixel ratio the width was resolved
+ * with goes along to take back out.
+ */
+function dashOf(lineStyle, width) {
+    const coefficients = dashCoefficientsOf(lineStyle);
+    if (!coefficients || width.ratio <= 0)
+        return null;
+    return { ...coefficients, pixelRatio: width.ratio };
 }
 /** The rings of a polygon (with the closing point dropped) */
 function polygonRings(feature) {
@@ -343,6 +352,8 @@ function pushElement(context, cacheKey, kind, paths, style) {
         // is not converted)
         geometry: () => drapeGeometryOf(cacheKey, paths, kind === 0),
         ...style,
+        // An outline that is not drawn has no pattern to lay out
+        dash: style.strokeWidthPx > 0 ? style.dash : null,
     });
     context.edgeCount += edges;
 }

package/dist/view/terrain/drape/renderer.d.ts

@@ -26,6 +26,13 @@ import { type DrapePackBuilder } from './bin-store.js';
 import { EDGE_UNITS } from './edge-constrain.js';
 import type { ResolvedTileEdges } from './stitch.js';
 export { EDGE_UNITS };
+/**
+ * The texture unit of the starts of the edges along their paths
+ *
+ * 5 and 7 to 9 hold the DEMs of the edges (`EDGE_UNITS`) and 6 the DEM atlas, so it comes after
+ * them (WebGL2 guarantees 16 units to a fragment shader).
+ */
+export declare const DRAPE_EDGE_START_UNIT = 10;
 /**
  * Upper limit on the sources of the factors
  *
@@ -92,6 +99,8 @@ export interface DrapeTileDraw {
     readonly grid: number;
     /** The ground size of this tile (meters). Used to compute the shading gradient */
     readonly groundMeters: number;
+    /** The zoom of this tile (it scales the lengths of the edges into dash pattern pixels) */
+    readonly tileZ: number;
     /**
      * The constraint for each edge (resolving T-junctions)
      *
@@ -123,10 +132,12 @@ export declare class DrapeRenderer {
     private variantName;
     private mesh;
     private edgeTex;
+    private edgeStartTex;
     private runTex;
     private cellTex;
     private styleTex;
     private edgeTexSize;
+    private edgeStartTexSize;
     private runTexSize;
     private cellTexSize;
     private styleTexSize;
@@ -179,6 +190,8 @@ export declare class DrapeRenderer {
      *
      * texStorage2D is immutable, so the texture is recreated whenever the required
      * size changes (once recreated, everything is sent again).
+     *
+     * @param channels The numbers per texel: 4 (RGBA32F) or 1 (R32F)
      */
     private uploadTexture;
 }