@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/renderers/line/line-geometry.js

@@ -0,0 +1,460 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The vertex data of the SDF line renderer (pure functions, no GL)
+ *
+ * The strip vertices shared by all instances, the coordinate texels and per-segment instances
+ * of a line, the instance color, and the number of subdivisions of a segment on terrain.
+ * Immediate mode and retained mode build their data with the same functions.
+ */
+import { EARTH } from '../../../shared/math/constants.js';
+import { resolveContentPixelRatio, resolvePixelRatio } from '../../../shared/utils/pixel-ratio.js';
+import { globeGridOf } from '../../globe-subdivision.js';
+import { calculateLngLatOffset } from '../../shaders/helpers.js';
+// The stride of the instance data (floats per instance)
+// indices(4) + extra(4) + color(4) = 12 floats
+export const INSTANCE_STRIDE = 12;
+export const INSTANCE_BYTES = INSTANCE_STRIDE * 4;
+/**
+ * The upper bound on subdivision points
+ *
+ * When terrain is enabled, a single segment is split into at most this many parts to draw it.
+ * A long straight line with only two vertices (34km as measured) sinks into the terrain
+ * between subdivision points when split coarsely, so the line looks broken up like a dashed
+ * line. The upper bound was decided from that (34km / 512 = 66m, which lands at the same
+ * granularity as the subdivision step).
+ * The vertex buffer of the strip statically holds this upper bound, but (512+1)*2 vertices =
+ * 4KB, so it is negligible as a resource. The number of vertices actually drawn is determined
+ * from u_stations every time.
+ */
+export const MAX_LINE_STATIONS = 512;
+/**
+ * A guideline for how many post-split segments a single draw call may produce (a guard against
+ * a vertex-count blow-up)
+ *
+ * The number of subdivisions is determined by the longest segment in the batch, so a single
+ * long line mixed into a batch full of short lines makes the whole batch use the maximum
+ * subdivision. This caps that.
+ */
+export const LINE_STATION_BUDGET = 500000;
+/**
+ * The strip vertices shared by all instances (side, station)
+ *
+ * side: 1=left, -1=right / station: the index of the subdivision point along the segment
+ *
+ * On terrain, a segment sinks into valleys unless it is subdivided. Here the subdivision is
+ * expressed as "the station index in the vertex buffer plus the vertex count at draw time".
+ * Neither the coordinate texture of the segment nor the instance array is touched, so both
+ * retained batches and the partial update for a vertex drag (patchRetainedBatchCoords) keep
+ * working as they are.
+ *
+ * With u_stations = 1, drawing only 4 vertices gives stations 0,0,1,1, which is exactly the
+ * same triangle strip as before terrain was introduced.
+ */
+// biome-ignore format: an array of vertex data
+export const STATION_VERTICES = (() => {
+    const data = new Float32Array((MAX_LINE_STATIONS + 1) * 2 * 2);
+    for (let s = 0; s <= MAX_LINE_STATIONS; s++) {
+        data[s * 4 + 0] = 1; // left
+        data[s * 4 + 1] = s;
+        data[s * 4 + 2] = -1; // right
+        data[s * 4 + 3] = s;
+    }
+    return data;
+})();
+/**
+ * Computes the color to pass as an instance attribute
+ *
+ * The fragment shader multiplies every color component by the coverage before output
+ * (premultiplied alpha), so the opacity is folded into every component and not just alpha.
+ * This gives the same composited result as the previous `u_color * (coverage * u_opacity)`.
+ *
+ * @internal
+ */
+export function toLineInstanceColor(color, opacity) {
+    const o = Number.isFinite(opacity) ? Math.min(Math.max(opacity, 0), 1) : 1;
+    return [color[0] * o, color[1] * o, color[2] * o, color[3] * o];
+}
+/**
+ * A Float32Array of at least `length` elements: the array itself when it is long enough,
+ * otherwise a new one of the next power of two
+ *
+ * @internal
+ */
+export function growFloat32(array, length) {
+    if (array.length >= length)
+        return array;
+    let size = 64;
+    while (size < length)
+        size *= 2;
+    return new Float32Array(size);
+}
+/**
+ * Rounds the origin of the relative coordinates to Float32
+ *
+ * u_center_lnglat, which is passed to the shader, is Float32, so the CPU-side subtraction uses
+ * the same rounded value to stay consistent (the same treatment as calculateOffsetUniforms).
+ *
+ * @internal
+ */
+export function normalizeOrigin(origin) {
+    return [Math.fround(origin[0]), Math.fround(origin[1])];
+}
+/**
+ * The default origin coordinate of a line batch (the first coordinate of the first item)
+ *
+ * @internal
+ */
+export function defaultLineOrigin(items) {
+    const first = items[0]?.coords[0];
+    return first ? [first[0], first[1]] : [0, 0];
+}
+/**
+ * Builds the coordinate texture and instance array of a line batch (a pure transformation)
+ *
+ * Shared between immediate mode (drawAll) and retained mode (buildRetainedBatch). Coordinates
+ * are stored as values relative to `origin`, so fixing `origin` makes the result independent
+ * of the camera.
+ *
+ * @param zoom The zoom used to compute the cumulative distance (for dashes; the zoom at draw
+ *   time for a dashed line, since the distance is in px at that zoom)
+ * @param origin The origin of the relative coordinates
+ * @param pixelRatio The injected rendering ratio (read from window each time when unspecified)
+ *
+ * @internal
+ */
+export function buildLineBatchArrays(items, zoom, origin, pixelRatio) {
+    // Get the rendering ratio (to convert CSS pixels into physical pixels)
+    //
+    // The ratio is chosen by the sign of the width (the "two ratios" in
+    // shared/utils/pixel-ratio.ts). A negative value = a width fixed in screen pixels uses the
+    // ratio that includes renderScale; a positive value = a width that the shader scales by
+    // 2^(u_zoom - createdZoom) uses the ratio without renderScale applied.
+    const screenDpr = resolvePixelRatio(pixelRatio);
+    const contentDpr = resolveContentPixelRatio(pixelRatio);
+    // Compute the total number of coordinates
+    let totalCoords = 0;
+    for (const item of items) {
+        totalCoords += item.coords.length;
+    }
+    if (totalCoords < 2)
+        return null;
+    // The texture size
+    const texSize = Math.max(2, Math.ceil(Math.sqrt(totalCoords)));
+    // The texture data (stores the relative coordinates)
+    const texData = new Float32Array(texSize * texSize * 4);
+    let coordOffset = 0;
+    for (const item of items) {
+        writeLineCoordTexels(texData, coordOffset, item.coords, origin);
+        coordOffset += item.coords.length;
+    }
+    // Generate the instance data
+    // 12 floats per instance: indices(4) + extra(4) + color(4)
+    let totalInstances = 0;
+    for (const item of items) {
+        totalInstances += item.coords.length - 1;
+    }
+    const instanceData = new Float32Array(totalInstances * INSTANCE_STRIDE);
+    let instanceIdx = 0;
+    let maxSegmentMeters = 0;
+    coordOffset = 0;
+    for (const item of items) {
+        const n = item.coords.length;
+        const meters = writeLineInstances(instanceData, instanceIdx, coordOffset, item.coords, {
+            closed: item.closed,
+            zoom,
+            dashPixelRatio: screenDpr,
+            // a_extra.y: the original line width (physical pixels)
+            strokeWidth: item.strokeWidth * (item.strokeWidth < 0 ? screenDpr : contentDpr),
+            createdZoom: item.createdZoom,
+            color: toLineInstanceColor(item.color, item.opacity),
+        });
+        if (meters > maxSegmentMeters)
+            maxSegmentMeters = meters;
+        instanceIdx += n - 1;
+        coordOffset += n;
+    }
+    return {
+        texData,
+        texSize,
+        instanceData,
+        instanceCount: totalInstances,
+        maxSegmentMeters,
+        maxSegmentMercator: maxInstanceSegmentMercator(instanceData, totalInstances, zoom, screenDpr),
+    };
+}
+/**
+ * The length of the longest segment of written instances on the Mercator plane (world units)
+ *
+ * The instances carry the length of each segment on screen at `zoom` (a_extra.w, in drawing-
+ * buffer px), which is the length on the Mercator plane times the size of the world in those
+ * px, so nothing is measured again.
+ *
+ * @param instanceData The instances written by {@link writeLineInstances}
+ * @param instanceCount The number of instances to look at
+ * @param zoom The zoom the lengths were written at
+ * @param dashPixelRatio The ratio the lengths were written with
+ *
+ * @internal
+ */
+export function maxInstanceSegmentMercator(instanceData, instanceCount, zoom, dashPixelRatio) {
+    let max = 0;
+    for (let i = 0; i < instanceCount; i++) {
+        const length = instanceData[i * INSTANCE_STRIDE + 7];
+        if (length > max)
+            max = length;
+    }
+    const world = WORLD_TILE_SIZE * 2 ** zoom * dashPixelRatio;
+    return world > 0 ? max / world : 0;
+}
+/**
+ * Builds the coordinate texture and instance array of packed lines
+ *
+ * It writes exactly what `buildLineBatchArrays` writes for the same lines (the same arithmetic in
+ * the same order), so the two paths draw the same picture.
+ *
+ * @internal
+ */
+export function buildPackedLineBatchArrays(lines, zoom, origin, pixelRatio) {
+    const screenDpr = resolvePixelRatio(pixelRatio);
+    const contentDpr = resolveContentPixelRatio(pixelRatio);
+    const { count, coords, stride, start, end } = lines;
+    let totalCoords = 0;
+    let totalInstances = 0;
+    for (let i = 0; i < count; i++) {
+        totalCoords += end[i] - start[i];
+        totalInstances += end[i] - start[i] - 1;
+    }
+    if (totalCoords < 2)
+        return null;
+    const texSize = Math.max(2, Math.ceil(Math.sqrt(totalCoords)));
+    const texData = new Float32Array(texSize * texSize * 4);
+    let coordOffset = 0;
+    for (let i = 0; i < count; i++) {
+        for (let v = start[i]; v < end[i]; v++) {
+            texData[coordOffset * 4] = coords[v * stride] - origin[0];
+            texData[coordOffset * 4 + 1] = coords[v * stride + 1] - origin[1];
+            coordOffset++;
+        }
+    }
+    const instanceData = new Float32Array(totalInstances * INSTANCE_STRIDE);
+    let instanceIdx = 0;
+    let maxSegmentMeters = 0;
+    coordOffset = 0;
+    for (let i = 0; i < count; i++) {
+        const first = start[i];
+        const n = end[i] - first;
+        const width = lines.strokeWidth[i];
+        const strokeWidth = width * (width < 0 ? screenDpr : contentDpr);
+        const createdZoom = lines.createdZoom[i];
+        const c = i * 4;
+        let linesofar = 0;
+        for (let k = 0; k < n - 1; k++) {
+            const ax = coords[(first + k) * stride];
+            const ay = coords[(first + k) * stride + 1];
+            const bx = coords[(first + k + 1) * stride];
+            const by = coords[(first + k + 1) * stride + 1];
+            const segmentLength = screenPixelDistanceXY(ax, ay, bx, by, zoom) * screenDpr;
+            const meters = segmentMetersXY(ax, ay, bx, by);
+            if (meters > maxSegmentMeters)
+                maxSegmentMeters = meters;
+            const base = (instanceIdx + k) * INSTANCE_STRIDE;
+            instanceData[base + 0] = coordOffset + k;
+            instanceData[base + 1] = coordOffset + k + 1;
+            instanceData[base + 2] = k > 0 ? coordOffset + k - 1 : -1;
+            instanceData[base + 3] = k + 1 < n - 1 ? coordOffset + k + 2 : -1;
+            instanceData[base + 4] = linesofar;
+            instanceData[base + 5] = strokeWidth;
+            instanceData[base + 6] = createdZoom;
+            instanceData[base + 7] = segmentLength;
+            instanceData[base + 8] = lines.color[c];
+            instanceData[base + 9] = lines.color[c + 1];
+            instanceData[base + 10] = lines.color[c + 2];
+            instanceData[base + 11] = lines.color[c + 3];
+            linesofar += segmentLength;
+        }
+        instanceIdx += n - 1;
+        coordOffset += n;
+    }
+    return {
+        texData,
+        texSize,
+        instanceData,
+        instanceCount: totalInstances,
+        maxSegmentMeters,
+        maxSegmentMercator: maxInstanceSegmentMercator(instanceData, totalInstances, zoom, screenDpr),
+    };
+}
+/**
+ * Writes the coordinates of one line into coordinate texels, as offsets from `origin`
+ *
+ * Each coordinate takes one RGBA texel starting at `coordOffset`: x = dLng, y = dLat (the
+ * offset from the origin computed at 64-bit precision). z and w are not written.
+ *
+ * @internal
+ */
+export function writeLineCoordTexels(target, coordOffset, coords, origin) {
+    for (let i = 0; i < coords.length; i++) {
+        // Compute the offset from the origin at 64-bit precision
+        const offset = calculateLngLatOffset(coords[i], origin);
+        target[(coordOffset + i) * 4] = offset[0]; // dLng (relative coordinate)
+        target[(coordOffset + i) * 4 + 1] = offset[1]; // dLat (relative coordinate)
+    }
+}
+/**
+ * Writes the instances (one per segment) of one line
+ *
+ * 12 floats per instance: indices(4) + extra(4) + color(4). The indices point into the
+ * coordinate texels of the line, which start at `coordOffset`; the previous and next indices
+ * wrap around on a closed line and are -1 at the ends of an open one.
+ *
+ * @param instanceStart The index of the first instance of the line in `target`
+ * @returns The length of the longest segment of the line (meters, approximate)
+ *
+ * @internal
+ */
+export function writeLineInstances(target, instanceStart, coordOffset, coords, params) {
+    const n = coords.length;
+    const { color } = params;
+    let linesofar = 0;
+    let maxSegmentMeters = 0;
+    for (let i = 0; i < n - 1; i++) {
+        const startIdx = coordOffset + i;
+        const endIdx = coordOffset + i + 1;
+        const prevIdx = i > 0 ? coordOffset + i - 1 : params.closed ? coordOffset + n - 2 : -1;
+        const nextIdx = i + 1 < n - 1 ? coordOffset + i + 2 : params.closed ? coordOffset + 1 : -1;
+        // The segment length on screen, in drawing-buffer px: the same unit as the screen length
+        // the vertex shader adds inside a segment and as the dash pattern (resolveDashUniform)
+        const segmentLength = screenPixelDistance(coords[i], coords[i + 1], params.zoom) * params.dashPixelRatio;
+        const meters = segmentMeters(coords[i], coords[i + 1]);
+        if (meters > maxSegmentMeters)
+            maxSegmentMeters = meters;
+        const base = (instanceStart + i) * INSTANCE_STRIDE;
+        target[base + 0] = startIdx;
+        target[base + 1] = endIdx;
+        target[base + 2] = prevIdx;
+        target[base + 3] = nextIdx;
+        target[base + 4] = linesofar; // a_extra.x: the starting cumulative distance (buffer px)
+        target[base + 5] = params.strokeWidth; // a_extra.y: the original line width (px)
+        target[base + 6] = params.createdZoom; // a_extra.z: createdZoom
+        target[base + 7] = segmentLength; // a_extra.w: the segment length (buffer px)
+        target[base + 8] = color[0]; // a_color.r
+        target[base + 9] = color[1]; // a_color.g
+        target[base + 10] = color[2]; // a_color.b
+        target[base + 11] = color[3]; // a_color.a
+        linesofar += segmentLength;
+    }
+    return maxSegmentMeters;
+}
+/**
+ * The side of the Web Mercator world at zoom 0, in CSS px
+ *
+ * maplibre lays the world out on 512 px tiles, so the world is `512 * 2^zoom` CSS px wide.
+ *
+ * @internal
+ */
+export const WORLD_TILE_SIZE = 512;
+/**
+ * The distance between two points on a flat Web Mercator map, in CSS px at `zoom`
+ *
+ * The projection stretches the latitude by 1 / cos(latitude) exactly as it stretches the
+ * longitude, so a length measured here is the same number of px on screen at any latitude.
+ * It is exact for an untilted Mercator view; a tilted or globe view shrinks the far side, and
+ * the vertex shader measures that part itself.
+ *
+ * @internal
+ */
+export function screenPixelDistance(a, b, zoom) {
+    return screenPixelDistanceXY(a[0], a[1], b[0], b[1], zoom);
+}
+/**
+ * {@link screenPixelDistance} with the coordinates as separate numbers
+ *
+ * @internal
+ */
+export function screenPixelDistanceXY(ax, ay, bx, by, zoom) {
+    const world = WORLD_TILE_SIZE * 2 ** zoom;
+    const dx = ((bx - ax) / 360) * world;
+    const dy = (mercatorY(by) - mercatorY(ay)) * world;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/** The Web Mercator y of a latitude, in world units (the world is 1 wide) */
+function mercatorY(lat) {
+    const latRad = (lat * Math.PI) / 180;
+    return Math.log(Math.tan(Math.PI / 4 + latRad / 2)) / (2 * Math.PI);
+}
+/**
+ * The distance between two points (meters, planar approximation)
+ *
+ * An approximation used only to decide the number of terrain subdivisions.
+ *
+ * @internal
+ */
+export function segmentMeters(a, b) {
+    return segmentMetersXY(a[0], a[1], b[0], b[1]);
+}
+/**
+ * {@link segmentMeters} with the coordinates as separate numbers
+ *
+ * @internal
+ */
+export function segmentMetersXY(ax, ay, bx, by) {
+    const midLatRad = (((ay + by) / 2) * Math.PI) / 180;
+    const dx = (bx - ax) * EARTH.METERS_PER_DEGREE * Math.cos(midLatRad);
+    const dy = (by - ay) * EARTH.METERS_PER_DEGREE;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+ * Whether the stations of the segments are placed along the Mercator plane (the globe) rather
+ * than along the degrees (the terrain)
+ *
+ * On the terrain the stations follow the mesh of the ground, in degrees as before. On the
+ * globe they follow the straight line of the Mercator plane, the path maplibre draws an edge
+ * along (`view/globe-subdivision.ts`).
+ *
+ * @internal
+ */
+export function lineStationsOnMercatorPlane(context) {
+    return !isTerrainStationActive(context) && globeGridOf(context, 'line') > 0;
+}
+/** Whether the terrain decides the stations (the terrain is drawn with a step) */
+function isTerrainStationActive(context) {
+    const terrain = context.renderState;
+    return terrain.active && terrain.stepMeters > 0;
+}
+/**
+ * Decides how many parts one segment is split into when drawn on terrain or on the globe
+ *
+ * On a flat map without terrain it always returns 1 (= the same 4-vertex strip as before).
+ * The terrain splits by its step in meters; the globe, when there is no terrain, by the line
+ * cell of maplibre's granularity on the Mercator plane.
+ *
+ * @param maxSegmentMercator The longest segment on the Mercator plane (world units; only the
+ *   globe reads it)
+ *
+ * @internal
+ */
+export function resolveLineStations(context, maxSegmentMeters, instanceCount, maxSegmentMercator = 0) {
+    let wanted;
+    if (isTerrainStationActive(context)) {
+        if (!(maxSegmentMeters > 0))
+            return 1;
+        wanted = Math.ceil(maxSegmentMeters / context.renderState.stepMeters);
+    }
+    else {
+        const grid = globeGridOf(context, 'line');
+        if (!(grid > 0) || !(maxSegmentMercator > 0))
+            return 1;
+        wanted = Math.ceil(maxSegmentMercator / grid);
+    }
+    let stations = Math.min(MAX_LINE_STATIONS, wanted);
+    if (stations <= 1)
+        return 1;
+    // Stop the vertex count from blowing up (a single long segment mixed in would otherwise
+    // make the whole batch use the maximum subdivision)
+    if (instanceCount > 0) {
+        const budget = Math.max(1, Math.floor(LINE_STATION_BUDGET / instanceCount));
+        stations = Math.min(stations, budget);
+    }
+    return Math.max(1, stations);
+}

package/dist/view/renderers/line/line-gl.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/view/renderers/line/line-gl.js

@@ -0,0 +1,236 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The GL resources of the SDF line renderer
+ *
+ * The vertex attribute layout shared by immediate mode and retained mode, the coordinate
+ * textures, and the create / patch / delete of a retained batch. The functions take the GL
+ * context and hold no state of their own, except the growable coordinate texture of
+ * immediate mode.
+ */
+import { calculateLngLatOffset } from '../../shaders/helpers.js';
+import { INSTANCE_BYTES, STATION_VERTICES } from './line-geometry.js';
+/**
+ * Sets up the quad vertex attributes (call it with the quad bound to ARRAY_BUFFER)
+ *
+ * @internal
+ */
+export function setupQuadAttribs(gl) {
+    // location 0: side (float)
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 8, 0);
+    // location 1: t (float)
+    gl.enableVertexAttribArray(1);
+    gl.vertexAttribPointer(1, 1, gl.FLOAT, false, 8, 4);
+}
+/**
+ * Sets up the instance attributes (call it with the instances bound to ARRAY_BUFFER)
+ *
+ * Immediate mode and retained mode use the same layout (stride = 48 bytes = 12 floats).
+ *
+ * @internal
+ */
+export function setupInstanceAttribs(gl) {
+    gl.enableVertexAttribArray(2);
+    gl.vertexAttribPointer(2, 4, gl.FLOAT, false, INSTANCE_BYTES, 0); // a_indices
+    gl.vertexAttribDivisor(2, 1);
+    gl.enableVertexAttribArray(3);
+    gl.vertexAttribPointer(3, 4, gl.FLOAT, false, INSTANCE_BYTES, 16); // a_extra (vec4)
+    gl.vertexAttribDivisor(3, 1);
+    gl.enableVertexAttribArray(4);
+    gl.vertexAttribPointer(4, 4, gl.FLOAT, false, INSTANCE_BYTES, 32); // a_color (vec4)
+    gl.vertexAttribDivisor(4, 1);
+}
+/**
+ * Resets the instance divisors and unbinds the vertex array (the end of an immediate draw)
+ *
+ * @internal
+ */
+export function releaseInstanceAttribs(gl) {
+    gl.vertexAttribDivisor(2, 0);
+    gl.vertexAttribDivisor(3, 0);
+    gl.vertexAttribDivisor(4, 0);
+    gl.bindVertexArray(null);
+}
+/** Sets nearest filtering and edge clamping on the texture bound to TEXTURE_2D */
+function setCoordTextureParams(gl) {
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+}
+/**
+ * Creates a coordinate texture (for retained mode; the size is allocated exactly)
+ *
+ * @param limit The largest side of a texture this GPU allows (MAX_TEXTURE_SIZE)
+ * @returns null when the coordinates do not fit in a texture of this GPU (the batch is then
+ *   not built)
+ *
+ * @internal
+ */
+export function createCoordTexture(gl, texData, texSize, limit) {
+    if (texSize > limit)
+        return null;
+    const texture = gl.createTexture();
+    if (!texture)
+        return null;
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, texSize, texSize);
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, texSize, texSize, gl.RGBA, gl.FLOAT, texData);
+    setCoordTextureParams(gl);
+    return texture;
+}
+/**
+ * The coordinate texture reused by immediate mode
+ *
+ * It is an immutable texture allocated with texStorage2D, so it is recreated only when a
+ * texSize larger than the allocated one arrives. `size` is the allocated side length, which is
+ * distinct from u_tex_size (the texSize of the data) passed to the shader.
+ *
+ * @internal
+ */
+export class ImmediateCoordTexture {
+    constructor(gl) {
+        Object.defineProperty(this, "gl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: gl
+        });
+        Object.defineProperty(this, "texture", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    /**
+     * Uploads the coordinates (returns with the texture bound to TEXTURE_2D)
+     *
+     * The allocated size is a power of two at least as large as texSize, which keeps
+     * reallocation infrequent. The upload covers only the texSize of the data, and the shader's
+     * u_tex_size is also given the texSize of the data. texelFetch only refers to the top-left
+     * texSize x texSize sub-rectangle, so the read is correct even when the allocated size is
+     * larger. The allocation never exceeds `limit` (MAX_TEXTURE_SIZE).
+     *
+     * @returns false when the coordinates do not fit in a texture of this GPU (nothing is drawn)
+     */
+    upload(texData, texSize, limit) {
+        const gl = this.gl;
+        if (texSize > limit)
+            return false;
+        if (!this.texture || texSize > this.size) {
+            if (this.texture)
+                gl.deleteTexture(this.texture);
+            let size = 2;
+            while (size < texSize)
+                size *= 2;
+            size = Math.min(size, limit);
+            const texture = gl.createTexture();
+            gl.bindTexture(gl.TEXTURE_2D, texture);
+            gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32F, size, size);
+            setCoordTextureParams(gl);
+            this.texture = texture;
+            this.size = size;
+        }
+        else {
+            gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        }
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, texSize, texSize, gl.RGBA, gl.FLOAT, texData);
+        return true;
+    }
+    /** Deletes the texture */
+    dispose() {
+        if (this.texture) {
+            this.gl.deleteTexture(this.texture);
+            this.texture = null;
+            this.size = 0;
+        }
+    }
+}
+/**
+ * Creates the GPU resources of a retained-mode line batch
+ *
+ * The batch owns its coordinate texture, quad vertex buffer, instance buffer, and VAO; none of
+ * them is shared with immediate mode.
+ *
+ * @param limit The largest side of a texture this GPU allows (MAX_TEXTURE_SIZE)
+ * @returns null when the coordinates do not fit in a texture of this GPU
+ *
+ * @internal
+ */
+export function createRetainedLineBatch(gl, arrays, shape, origin, widthZoom, limit) {
+    const texture = createCoordTexture(gl, arrays.texData, arrays.texSize, limit);
+    if (!texture)
+        return null;
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    // The quad vertices (held separately from the shared immediate-mode buffer)
+    const quadBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, STATION_VERTICES, gl.STATIC_DRAW);
+    setupQuadAttribs(gl);
+    // The instance attributes (the layout is identical to immediate mode)
+    const instanceBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, instanceBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, arrays.instanceData, gl.STATIC_DRAW);
+    setupInstanceAttribs(gl);
+    gl.bindVertexArray(null);
+    return {
+        vao,
+        quadBuffer,
+        instanceBuffer,
+        texture,
+        texSize: arrays.texSize,
+        instanceCount: arrays.instanceCount,
+        shape,
+        origin,
+        widthZoom,
+        maxSegmentMeters: arrays.maxSegmentMeters,
+        maxSegmentMercator: arrays.maxSegmentMercator,
+    };
+}
+/**
+ * Rewrites single texels of the coordinate texture of a retained batch
+ *
+ * See SDFLineRenderer.patchRetainedBatchCoords for why only the texels are rewritten.
+ *
+ * @internal
+ */
+export function patchRetainedCoordTexels(gl, batch, updates) {
+    if (updates.length === 0)
+        return;
+    const texSize = batch.texSize;
+    const capacity = texSize * texSize;
+    // The upload buffer for one texel (z/w stay 0, the same as at build time)
+    const texel = new Float32Array(4);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, batch.texture);
+    for (const { coordIndex, lngLat } of updates) {
+        // Ignore out-of-range indices (a safety net for when the batch and the caller diverge)
+        if (!Number.isInteger(coordIndex) || coordIndex < 0 || coordIndex >= capacity)
+            continue;
+        // The same conversion as at build time (the offset from the origin at 64-bit precision)
+        const offset = calculateLngLatOffset(lngLat, batch.origin);
+        texel[0] = offset[0];
+        texel[1] = offset[1];
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, coordIndex % texSize, Math.floor(coordIndex / texSize), 1, 1, gl.RGBA, gl.FLOAT, texel);
+    }
+}
+/**
+ * Deletes the GPU resources of a retained-mode line batch
+ *
+ * @internal
+ */
+export function deleteRetainedLineBatch(gl, batch) {
+    gl.deleteVertexArray(batch.vao);
+    gl.deleteBuffer(batch.quadBuffer);
+    gl.deleteBuffer(batch.instanceBuffer);
+    gl.deleteTexture(batch.texture);
+}

package/dist/view/renderers/line/line-shader.d.ts

@@ -0,0 +1 @@
+export {};