@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/layer/frame-state.js

@@ -0,0 +1,484 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { isLocallyHidden } from '../../store/local-visibility.js';
+import { calculateOffsetUniforms, translateMatrixByLongitude, } from '../shaders/helpers.js';
+import { anchorViewportOf, clearAnchorFrame, setAnchorFrame } from '../terrain/anchor.js';
+import { getCameraMercator, getMapTerrain, getRenderableTerrainTiles, getTerrainMeshSize, getTerrainTileData, } from '../terrain/detect.js';
+import { resolveDrapeLight } from '../terrain/drape/renderer.js';
+import { setQuadDrapeFrame, setTerrainSurfacesFlattened } from '../terrain/state.js';
+import { getSelectedFeatureIds } from '../ui/helper.js';
+import { applyDrawBlendState } from './blend.js';
+import { TERRAIN_ANALYTIC_MIN_ZOOM, } from './drape-planner.js';
+/**
+ * The style zoom (the zoom that the rendering reads; a value that absorbs the steps of the
+ * elevation settlement)
+ *
+ * The elevation settlement of maplibre "rewrites the zoom number while keeping the spatial
+ * position of the camera fixed". Since the screen does not move by a single pixel, nothing
+ * should change size either. This rendering, however, derives the line widths, the labels,
+ * the point sizes and the drape factors from the zoom number, so a step in the number is a
+ * resize of every element, that is, a jolt that anyone can see. A first version that blended
+ * it in with a time-constant smoothing turned into "a 250 ms breath on every settlement" and
+ * was rejected.
+ *
+ * The correct rule is absorption: a change of the zoom number while the camera stays where it
+ * is (= a settlement) is not reflected in the style zoom. During a real operation (zoom, pan,
+ * inertia) it follows the raw increments. The difference from the settlements (the gap between
+ * the style zoom and the raw zoom) is bounded at around ±0.3 as the elevation goes up and down,
+ * and it matters more that the apparent sizes keep matching the real scale.
+ *
+ * A change of the zoom number with no operation in progress is not always a settlement: `jumpTo`
+ * and `setZoom` move the camera at once, and the frame after them sees a camera that is not
+ * moving. So the position of the camera tells them apart: when it moved, the style zoom takes
+ * the raw zoom as it is (absorbing that change would keep every size at the old scale from then
+ * on). When the position cannot be read, a change of the zoom number is not absorbed.
+ *
+ * The rule behind the test is an invariant, not a measurement: a settlement keeps the camera
+ * where it is in space and only describes it again (a new zoom number and a new center on the
+ * terrain under it), while any change of the zoom at the same pitch moves the camera along its
+ * line of sight and changes its altitude by the factor `2^-Δzoom`. The altitude therefore
+ * separates the two for any change of the zoom, and the tolerances only have to absorb the
+ * floating-point noise of describing the same camera again (see `sameCameraPosition`).
+ *
+ * How the style zoom returns to the raw zoom follows from the same rule:
+ *
+ * - `jumpTo`, `setZoom` and any other move of the camera that changes the zoom within one frame:
+ *   the frame after it sees the camera moved, and the style zoom takes the raw zoom as it is (the
+ *   gap of earlier settlements is dropped; a jump that keeps the zoom number keeps the gap)
+ * - an animated move (`easeTo`, `flyTo`, a gesture, inertia): the frames of the move follow the
+ *   increments of the raw zoom and keep the gap of earlier settlements, so the sizes do not jump
+ *   when the move starts; the gap stays after the move ends until a move of the first kind
+ * - a settlement: absorbed, and the gap changes by its step (bounded by about ±0.3 as the
+ *   elevation under the camera goes up and down)
+ *
+ * @internal
+ */
+export class StyleZoom {
+    constructor() {
+        /** The style zoom. null = not initialized */
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The raw zoom of the previous frame (recorded to follow the increments during an operation) */
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The position of the camera in the previous frame (null = unknown) */
+        Object.defineProperty(this, "camera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Advances by one frame and returns the style zoom of that frame
+     *
+     * @param camera The position of the camera in this frame (null when it cannot be read)
+     */
+    update(rawZoom, cameraBusy, camera = null) {
+        if (this.value === null || this.raw === null) {
+            this.value = rawZoom;
+        }
+        else if (cameraBusy) {
+            this.value += rawZoom - this.raw;
+        }
+        else if (rawZoom !== this.raw && !sameCameraPosition(this.camera, camera)) {
+            this.value = rawZoom;
+        }
+        this.raw = rawZoom;
+        this.camera = camera;
+        return this.value;
+    }
+}
+/**
+ * Mercator distance under which the camera has not moved sideways (about 40 m on the ground)
+ *
+ * The camera maplibre reports after a settlement is computed back from the new zoom and center,
+ * and its position on the ground drifts by the rounding of that computation (1 to 2 m seen over
+ * steep terrain at pitch 60). The altitude is the test that tells a settlement from a jump (any
+ * change of the zoom changes it); this bound only keeps a jump far sideways at the same altitude
+ * from being taken for a settlement, so it is set well above the drift and far below any jump a
+ * host makes on purpose.
+ */
+const CAMERA_STILL_MERCATOR = 1e-6;
+/**
+ * Altitude difference (m) under which the camera has not moved up or down, for a camera close to
+ * the ground (the floor of the relative tolerance below)
+ */
+const CAMERA_STILL_METERS = 0.01;
+/**
+ * The same, relative to the altitude
+ *
+ * A change of the zoom by Δ changes the altitude by the factor `2^-Δ`, a relative change of about
+ * `0.69 * Δ`: this tolerance takes any change of the zoom above about 1.5e-7 for a move of the
+ * camera, at every altitude, while the noise of describing the same camera again (float64
+ * arithmetic on a few terms) stays orders of magnitude below it.
+ */
+const CAMERA_STILL_RELATIVE = 1e-7;
+/** Whether two positions of the camera are the same place (false when either is unknown) */
+function sameCameraPosition(a, b) {
+    if (!a || !b)
+        return false;
+    const altitudeTolerance = Math.max(CAMERA_STILL_METERS, Math.abs(a[2]) * CAMERA_STILL_RELATIVE);
+    return (Math.abs(a[0] - b[0]) <= CAMERA_STILL_MERCATOR &&
+        Math.abs(a[1] - b[1]) <= CAMERA_STILL_MERCATOR &&
+        Math.abs(a[2] - b[2]) <= altitudeTolerance);
+}
+/**
+ * Builds the state of a frame (done once by the first slot)
+ *
+ * It sets up the shaders and the anchor projection of the frame, plans the analytic drape,
+ * picks the features of the immediate path and the selection, and plans the copies of the world.
+ */
+export function buildFrameState(input) {
+    const { gl, renderers: r, map, store, terrainContext, drape, renderOptions } = input;
+    const { zoom, rawZoom, dpr, terrainState } = input;
+    const { shaderData, defaultProjectionData } = renderOptions;
+    const mapTerrain = terrainState.active ? getMapTerrain(map) : null;
+    // Shader initialization
+    const center = map.getCenter();
+    const centerLngLat = [center.lng, center.lat];
+    r.shaderInitializer.incrementSdfLineFrame();
+    r.shaderInitializer.ensureShaders(shaderData);
+    r.shaderInitializer.setProjectionData(defaultProjectionData);
+    const mainMatrixArray = Array.from(defaultProjectionData.mainMatrix);
+    const baseOffsetUniforms = calculateOffsetUniforms(centerLngLat, mainMatrixArray);
+    r.shaderInitializer.applyOffsetUniforms(baseOffsetUniforms);
+    // Shader initialization of the BoxSelectionRenderer
+    r.boxSelectionRenderer.ensureShader(shaderData);
+    const boxOffsetUniforms = calculateOffsetUniforms(centerLngLat, mainMatrixArray);
+    r.boxSelectionRenderer.setOffsetUniforms(boxOffsetUniforms);
+    // Establish the anchor projection (the single source shared by the positions of the points
+    // and the handles and by the hit testing) with the values of this frame. The matrix, the
+    // offsets and the elevation scale used for rendering are passed through as they are, so the
+    // projection on the CPU side uses the same formula and the same branches as the vertex
+    // shader. When the terrain is inactive it is removed and hit testing goes back to the project
+    // of MapLibre (exactly the same path as before the terrain was introduced).
+    if (terrainState.active && mapTerrain) {
+        const viewport = anchorViewportOf(map);
+        setAnchorFrame(terrainContext, {
+            terrain: mapTerrain,
+            // The elevation of the surface maplibre draws (terrain/ground.ts)
+            elevationQuery: map,
+            zoom,
+            elevationScale: terrainState.elevationScale,
+            mainMatrix: mainMatrixArray,
+            offsetUniforms: boxOffsetUniforms,
+            width: viewport.width,
+            height: viewport.height,
+            // Used by the occlusion test of the symbols (ghost) to trace the segment from the camera
+            // to the anchor
+            cameraMercator: getCameraMercator(map, terrainState.elevationScale),
+        });
+    }
+    else {
+        clearAnchorFrame(terrainContext);
+    }
+    // Decide first whether retained mode can draw (whether the renderers support it). Retained
+    // mode draws the batches prepared per layer, so neither walking the feature list nor the
+    // per-feature viewport filtering is needed. The off-screen thinning is done by renderLayers
+    // per chunk (the bbox of the expanded viewport is computed once per frame).
+    // Whether the analytic drape can be used (the path that paints features as ground pixels).
+    // When it can, the polygons and lines are drawn there and only the rest (points and so on)
+    // goes through the previous path (drape-planner.ts).
+    const drapeUsable = drape.planFrame({
+        gl,
+        resolveStyles: () => r.batchManager.getRetainedRenderers()?.styles ?? r.featureDrawer,
+        mapTerrain,
+        dpr,
+        zoom,
+        rawZoom,
+    });
+    const useRetained = !drapeUsable && input.retainedAvailable && r.batchManager.getRetainedRenderers() !== undefined;
+    // Viewport filtering. The display list is "the list that should be shown", which
+    // excludes the local visibility of this client in addition to the shared visible flag.
+    const excluded = drapeUsable ? drape.excluded : null;
+    // An image interleaved into the stacking order is drawn between the sections of the drape,
+    // so it is excluded from the later layer rendering (drawing it in both would double it)
+    const drawnQuadBreaks = drapeUsable ? drape.quadBreaks : [];
+    const interleavedQuadIds = new Set();
+    for (const brk of drawnQuadBreaks)
+        interleavedQuadIds.add(brk.featureId);
+    // The features in view come from the spatial index and are put in draw order by the kept
+    // display list (display-list.ts), so the cost follows what is on screen
+    const features = useRetained
+        ? []
+        : input.displayList
+            .inOrder(r.viewportFilter.getVisibleIds())
+            .filter((feature) => excluded === null || (excluded.has(feature.id) && !interleavedQuadIds.has(feature.id)));
+    // The single source of truth of the selection carries a kind. A group / layer selection is
+    // resolved to its members and reflected on the map (getSelectedFeatureIds absorbs
+    // feature / group / layer).
+    const selectedIds = getSelectedFeatureIds(store);
+    const selectedIdSet = new Set(selectedIds);
+    // The features for the selection UI are resolved directly from the selected ids. This keeps
+    // them independent of the rendering path (retained / immediate mode), so the selection UI is
+    // the same either way. They used to be picked from the features after the viewport filter, so
+    // a selected feature off the screen got no selection UI. Now it does (it is drawn correctly
+    // when part of the selection box reaches into the screen).
+    const selectedFeatures = [];
+    for (const id of selectedIds) {
+        const feature = store.getFeature(id);
+        if (!feature?.visible || isLocallyHidden(feature, store))
+            continue;
+        selectedFeatures.push(feature);
+    }
+    // Compositing of translucency (alpha blending; the reason is written in blend.ts)
+    //
+    // This state is a contract for the whole frame. An external renderer (a custom feature type,
+    // an overlay) may rewrite the blend function for its own purposes, and if it comes back
+    // having left it rewritten, everything drawn afterwards is composited wrongly. This function
+    // is called again at the point control comes back, to establish the contract again.
+    const restoreBlendState = () => applyDrawBlendState(gl);
+    // The degenerate band of a wide view is drawn without depth
+    //
+    // Over a wide area the relief of the terrain is tiny on screen (at z8.6 a 1,000 m ridge is a
+    // dozen or so pixels), so turning off the occlusion hardly changes how the distance looks. On
+    // the other hand the vertex displacement path has the property that "the fill sinks into the
+    // ground where it disagrees with the terrain mesh", and that punch-through stands out as
+    // white dots in areas dense with polygons, such as a city center
+    // (repro = 8.60/35.54609/139.46385/0.0/17.0). With the depth off, sinking cannot happen by
+    // construction. It is not applied in the band where the analytic drape is running (there the
+    // features are ground pixels themselves, so the occlusion works correctly).
+    const wideFallback = !drapeUsable && rawZoom <= TERRAIN_ANALYTIC_MIN_ZOOM;
+    // In a wide band the polygons and lines are drawn flat (the reason is surfacesFlattened in
+    // terrain/context.ts). It is the same band and the same reason as turning off the depth.
+    // Symbols (points, handles, text quads) are out of scope, so stopping it here does not
+    // break the agreement between the anchor projection and the hit testing.
+    setTerrainSurfacesFlattened(terrainContext, terrainState.active && wideFallback);
+    const quadDrapeFrame = buildQuadDrapeFrame(input, mapTerrain);
+    // Context for the custom renderers
+    const customRendererContext = {
+        shaderData,
+        centerLngLat,
+        mainMatrixArray,
+        pixelRatio: dpr,
+        terrain: terrainContext,
+        // An overlay does not belong to a layer. The layer loop passes each layer its own opacity
+        opacity: 1,
+        sdfLineRenderer: r.sdfLineRenderer,
+        fillShaderManager: r.fillShaderManager,
+        pointShapeRenderer: r.pointShapeRenderer,
+    };
+    // Separate the layer-aware overlay renderers from the rest
+    const layerAwareRenderers = [];
+    const otherRenderers = [];
+    for (const renderer of input.overlayRenderers) {
+        if ('drawForLayer' in renderer && typeof renderer.drawForLayer === 'function') {
+            layerAwareRenderers.push(renderer);
+        }
+        else {
+            otherRenderers.push(renderer);
+        }
+    }
+    if (drapeUsable)
+        drape.reportImmediate(features.length);
+    const drapeLight = resolveDrapeLight(map.getBearing());
+    const drapeDraws = drape.buildDraws({
+        drapeUsable,
+        shaderData,
+        mapTerrain,
+        getProjectionData: renderOptions.getProjectionData,
+    });
+    // The copies of the world in view
+    const baseCopy = {
+        lngShift: 0,
+        view: undefined,
+        projectionData: defaultProjectionData,
+        offsetUniforms: baseOffsetUniforms,
+        customRendererContext,
+        features,
+        selectedFeatures,
+        terrainState,
+    };
+    const copies = planCopies(baseCopy, {
+        renderers: r,
+        displayList: input.displayList,
+        center: centerLngLat,
+        mainMatrixArray,
+        useRetained,
+        excluded,
+        interleavedQuadIds,
+        transition: defaultProjectionData.projectionTransition ?? 0,
+    });
+    return {
+        segments: input.segments.slice(),
+        layerOrder: store.getLayerOrder(),
+        lastIndex: -1,
+        shaderData,
+        defaultProjectionData,
+        getProjectionData: renderOptions.getProjectionData,
+        zoom,
+        rawZoom,
+        dpr,
+        terrainState,
+        mapTerrain,
+        centerLngLat,
+        mainMatrixArray,
+        drapeUsable,
+        wideFallback,
+        useRetained,
+        features,
+        selectedIdSet,
+        selectedFeatures,
+        customRendererContext,
+        layerAwareRenderers,
+        otherRenderers,
+        quadDrapeFrame,
+        restoreBlendState,
+        drapeReady: drapeDraws.ready,
+        drapeLight,
+        drapeTileDraws: drapeDraws.tileDraws,
+        drapeElementsTotal: drape.tileStore.elementCount,
+        drapeAboveStoreStart: drape.tileStore.aboveStoreStart,
+        drapeEntryStarts: drape.tileStore.entryStarts,
+        pendingQuads: drapeDraws.pendingQuads,
+        drapeFallbackQuads: drapeDraws.fallbackQuads,
+        baseCopy,
+        copies,
+    };
+}
+/**
+ * Installs the entry point that pins the textured quads (Image, the fill of a quad that
+ * carries text) to the ground
+ *
+ * A billboard of four corner vertices always cuts in when the terrain inside pokes out of the
+ * plane through those corners. With this entry point present, QuadShader takes the path that
+ * pins it as "ground pixels" instead of a billboard. In a frame without it (no terrain, the
+ * DEM has not arrived, the shaders cannot be built) it falls back to the subdivision path or
+ * to the previous billboard.
+ */
+function buildQuadDrapeFrame(input, mapTerrain) {
+    const { terrainState, renderOptions, map } = input;
+    if (!terrainState.active || !mapTerrain)
+        return null;
+    const quadTerrain = mapTerrain;
+    const quadDrapeRenderer = input.drape.quadRenderer(input.gl);
+    const quadTiles = getRenderableTerrainTiles(quadTerrain);
+    if (quadTiles.length === 0)
+        return null;
+    // The DEM and the ProjectionData are looked up once per tile in this frame (baking them
+    // in would keep drawing the coarse elevation of the parent tile)
+    const terrainDataCache = new Map();
+    const projectionCache = new Map();
+    const quadDrapeFrame = {
+        renderer: quadDrapeRenderer,
+        shaderData: renderOptions.shaderData,
+        tiles: quadTiles,
+        meshSize: getTerrainMeshSize(quadTerrain),
+        light: resolveDrapeLight(map.getBearing()),
+        // The depth test stays on through the layer rendering, whether or not the drape was used,
+        // and goes off from the foreground on (renderForeground)
+        keepDepthTest: true,
+        getTerrainData(tile) {
+            const hit = terrainDataCache.get(tile.tileID);
+            if (hit !== undefined)
+                return hit;
+            const data = getTerrainTileData(quadTerrain, tile);
+            terrainDataCache.set(tile.tileID, data);
+            return data;
+        },
+        getProjectionData(tile) {
+            const hit = projectionCache.get(tile.tileID);
+            if (hit !== undefined)
+                return hit;
+            // getProjectionData throws when the shape of tileID does not match. This keeps the
+            // whole rendering from failing if it changes between versions.
+            let data = null;
+            try {
+                data = renderOptions.getProjectionData({
+                    tileID: tile.tileID,
+                });
+            }
+            catch {
+                data = null;
+            }
+            projectionCache.set(tile.tileID, data);
+            return data;
+        },
+    };
+    setQuadDrapeFrame(input.terrainContext, quadDrapeFrame);
+    return quadDrapeFrame;
+}
+/**
+ * Plans the copies of the world drawn in this frame
+ *
+ * One copy (the base one, unchanged) unless the view crosses the antimeridian. Across it,
+ * each copy gets its range of the view, the features of that range, the virtual camera
+ * (center and matrix moved by the copy's shift, computed in 64 bits) and the DEM atlas in the
+ * frame of that camera. The globe draws with maplibre's projectTile, which has no seam, so it
+ * keeps one copy.
+ */
+export function planCopies(baseCopy, options) {
+    const filter = options.renderers?.viewportFilter;
+    if (!filter || typeof filter.getCopies !== 'function' || options.transition > 0) {
+        return [baseCopy];
+    }
+    const viewCopies = filter.getCopies();
+    if (viewCopies.length === 1 && viewCopies[0].lngShift === 0)
+        return [baseCopy];
+    return viewCopies.map((viewCopy) => {
+        let visibleIds = null;
+        const getVisibleIds = () => {
+            if (!visibleIds)
+                visibleIds = filter.getVisibleIdsIn(viewCopy.bounds);
+            return visibleIds;
+        };
+        const view = { bounds: viewCopy.bounds, getVisibleIds };
+        const features = options.useRetained
+            ? []
+            : options.displayList
+                .inOrder(getVisibleIds())
+                .filter((feature) => options.excluded === null ||
+                (options.excluded.has(feature.id) && !options.interleavedQuadIds.has(feature.id)));
+        const selected = baseCopy.selectedFeatures.filter((feature) => getVisibleIds().has(feature.id));
+        const shift = viewCopy.lngShift;
+        if (shift === 0) {
+            return { ...baseCopy, view, features, selectedFeatures: selected };
+        }
+        // The virtual camera of this copy
+        const matrix = translateMatrixByLongitude(options.mainMatrixArray, shift);
+        const center = [options.center[0] - shift, options.center[1]];
+        // The same array type as the matrix maplibre hands over (it is uploaded as it is)
+        const baseMatrix = baseCopy.projectionData.mainMatrix;
+        const projectionData = {
+            ...baseCopy.projectionData,
+            mainMatrix: (baseMatrix instanceof Float32Array
+                ? new Float32Array(matrix)
+                : new Float64Array(matrix)),
+        };
+        const base = baseCopy.terrainState;
+        const terrainState = base.active
+            ? {
+                ...base,
+                atlasRect: [
+                    base.atlasRect[0] - shift / 360,
+                    base.atlasRect[1],
+                    base.atlasRect[2],
+                    base.atlasRect[3],
+                ],
+            }
+            : base;
+        return {
+            lngShift: shift,
+            view,
+            projectionData,
+            offsetUniforms: calculateOffsetUniforms(center, matrix),
+            customRendererContext: {
+                ...baseCopy.customRendererContext,
+                centerLngLat: center,
+                mainMatrixArray: matrix,
+            },
+            features,
+            selectedFeatures: selected,
+            terrainState,
+        };
+    });
+}

package/dist/view/layer/gl-state.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The GL state of a slot
+ *
+ * maplibre resets the GL state between the slots, so every slot establishes the state its frame
+ * assumes when it starts and hands the defaults of maplibre back when it ends. Every switch of
+ * the blending, the depth test, the depth function, the depth mask and the polygon offset made
+ * by the layer itself (outside the renderers) is here:
+ *
+ * - `applySegmentGlState` / `restoreSegmentGlState`: the start and the end of a slot
+ * - `applySegmentDepthState`: the depth state of the layer rendering, set at the start of a
+ *   slot and again after the drape
+ * - `applyDrapeGlState`: the analytic drape (premultiplied alpha, LEQUAL, no offset)
+ * - `enterSymbolGlState`: the foreground, the selection UI and the overlays (always in front)
+ *
+ * The record of the depth test (depth-state.ts) is updated by every switch, and the blend state
+ * of the frame (blend.ts) is re-established through `restoreBlendState`.
+ */
+import type { TerrainContext, TerrainRenderState } from '../terrain/context.js';
+import type { QuadDrapeFrame } from '../terrain/drape/quad.js';
+import type { DrapeLight } from '../terrain/drape/renderer.js';
+/** The parts of the frame that decide the GL state of a slot */
+export interface SegmentGlFrame {
+    readonly terrainState: TerrainRenderState;
+    readonly drapeLight: DrapeLight;
+    readonly wideFallback: boolean;
+    readonly quadDrapeFrame: QuadDrapeFrame | null;
+    readonly restoreBlendState: () => void;
+}
+/** Establishes the GL state this frame assumes, at the start of the drawing of a slot */
+export declare function applySegmentGlState(gl: WebGL2RenderingContext, terrainContext: TerrainContext, f: SegmentGlFrame): void;
+/**
+ * Establishes the depth state of the layer rendering of a slot
+ *
+ * `applySegmentGlState` sets it at the start of a slot, and the drape of the segment, which
+ * changes the depth function and the offset, hands it back with this before the layers are
+ * drawn. The layers are therefore drawn in one depth state whether or not the drape was used.
+ * What the drape cannot paint (dashed lines, polygons with a dashed outline, the geometry being
+ * drawn, the features of extensions, the datasets not handed over to it) is
+ * drawn after it by the vertex displacement path and must be hidden by the terrain in the same
+ * way. Symbols switch the depth test off themselves (`drawBillboardsWithoutDepth`).
+ */
+export declare function applySegmentDepthState(gl: WebGL2RenderingContext, terrainContext: TerrainContext, f: Pick<SegmentGlFrame, 'terrainState' | 'wideFallback'>): void;
+/** Restores the GL state to the defaults of maplibre at the end of the drawing of a slot */
+export declare function restoreSegmentGlState(gl: WebGL2RenderingContext, f: SegmentGlFrame): void;
+/**
+ * Establishes the GL state of the analytic drape
+ *
+ * Composite with premultiplied alpha (the coverage is evaluated once per pixel, so an overlap
+ * is never painted twice).
+ *
+ * What the drape draws is the ground itself. It coincides with the terrain surface of maplibre
+ * at the same height, so on pixels of equal depth the winner wavers and the edges get eaten away
+ * (pronounced on a shallow slope; confirmed in the field). The depth function is set to LEQUAL so
+ * that equality wins, and the slope-proportional bias (which exists to fill the sinking of the
+ * chords of the CPU subdivision) is not applied: the surfaces of the drape are not chords, so it
+ * is not needed. The occlusion is carried by the depth test itself, so it must not be turned off.
+ *
+ * The depth bias (polygonOffset) is not used. The factor is proportional to the screen-space
+ * gradient of the depth, so it acts too strongly on a shallow slope, and its unit depends on the
+ * resolution of the depth buffer. The drape lifts its vertices ever so slightly to win instead
+ * (DRAPE_LIFT_RATIO in drape/renderer.ts).
+ */
+export declare function applyDrapeGlState(gl: WebGL2RenderingContext): void;
+/**
+ * Goes back to the drape after an image was interleaved (the blending and the depth test; the
+ * depth function and the offset were left as the drape set them)
+ */
+export declare function resumeDrapeGlState(gl: WebGL2RenderingContext): void;
+/**
+ * Establishes the GL state of the symbols and the UI (no depth test)
+ *
+ * From here on it is not "something painted onto the ground" but the symbols and the UI.
+ * Points, handles and selection boxes are billboards, so with the depth in effect they disappear
+ * entirely as soon as they sink a little into the ground. Measured, enabling the terrain made
+ * every point invisible. Symbols are always drawn in front.
+ */
+export declare function enterSymbolGlState(gl: WebGL2RenderingContext): void;