@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/renderers/polygon/terrain-cull.d.ts

@@ -0,0 +1,3 @@
+import type { TerrainContext } from '../../terrain/context.js';
+/** Draws with back-face culling enabled only while terrain is active */
+export declare function drawFillWithTerrainCull(gl: WebGL2RenderingContext, terrain: TerrainContext, draw: () => void): void;

package/dist/view/renderers/polygon/terrain-cull.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** Draws with back-face culling enabled only while terrain is active */
+export function drawFillWithTerrainCull(gl, terrain, draw) {
+    const active = terrain.renderState.active;
+    if (active) {
+        gl.enable(gl.CULL_FACE);
+        gl.cullFace(gl.BACK);
+        gl.frontFace(gl.CCW);
+    }
+    draw();
+    if (active)
+        gl.disable(gl.CULL_FACE);
+}

package/dist/view/renderers/polygon/triangulator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Injection point for polygon triangulation
+ *
+ * Retained-mode batch building (buildRetained) can receive the triangulation of the
+ * fill through this injection point. If none is passed, earcut is called on the spot
+ * as before.
+ *
+ * Triangulating a huge polygon (a water body on the order of a million vertices)
+ * takes more than ten seconds in one go, so the dataset path injects
+ * an implementation that slices the work over time (display/triangulation.ts) here.
+ * For a polygon whose triangulation has not finished yet, null is returned, and the
+ * caller omits the fill of that polygon and puts it into the batch with the outline
+ * only. Once the triangulation finishes, the injecting side prompts a rebuild.
+ *
+ * The renderer (view) does not know the implementation being injected. Only the
+ * types are placed here in order to keep that direction of dependency.
+ */
+/**
+ * A triangulation request
+ */
+export interface TriangulationRequest {
+    /** Feature ID used for cache and job identity (execution is synchronous without it) */
+    featureId: string | undefined;
+    /** Part number within a MultiPolygon (0 for a single polygon) */
+    partIndex: number;
+    /** Coordinate sequence flattened over all rings (the output of buildEarcutInput) */
+    flatCoords: number[];
+    /** Start vertex indices of the inner rings */
+    holeIndices: number[];
+}
+/**
+ * A supplier of triangulations
+ */
+export interface PolygonTriangulator {
+    /**
+     * Returns the triangulated index sequence
+     *
+     * @returns null while the triangulation has not finished yet (the fill is omitted)
+     */
+    triangulate(request: TriangulationRequest): number[] | null;
+}

package/dist/view/renderers/polygon/triangulator.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/view/renderers/retained.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The set of renderers for retained mode
+ *
+ * Rendering that is not rebuilt every frame, such as a
+ * dataset, calls batch building (creating GPU resources) and drawing
+ * (bind + uniforms + draw call) separately. This module gathers just those
+ * entry points, so that the drawing side does not depend on the internal
+ * structure of BatchManager.
+ *
+ * The builders from packed typed arrays (`buildRetainedPacked` and `buildRetainedPackedBatch`)
+ * are optional: a set without them gets the same data as arrays of objects.
+ *
+ * The immediate-mode API (drawAll / drawBatch) is not part of this type. A
+ * retained-mode batch does not share resources with the shared buffers and
+ * shared textures of immediate mode.
+ */
+import type { FeatureDrawer } from './drawer.js';
+import type { SDFLineRenderer } from './line/sdf-line.js';
+import type { PointInstanceRenderer } from './point/point-instance.js';
+import type { SDFPolygonRenderer } from './polygon/sdf-polygon.js';
+/** Retained-mode API for lines */
+export type RetainedLineRenderer = Pick<SDFLineRenderer, 'buildRetainedBatch' | 'drawRetainedBatch' | 'disposeRetainedBatch'> & Partial<Pick<SDFLineRenderer, 'buildRetainedPackedBatch'>>;
+/** Retained-mode API for polygons */
+export type RetainedPolygonRenderer = Pick<SDFPolygonRenderer, 'buildRetained' | 'drawRetained' | 'disposeRetained'>;
+/** Retained-mode API for points */
+export type RetainedPointRenderer = Pick<PointInstanceRenderer, 'buildRetained' | 'drawRetained' | 'disposeRetained'> & Partial<Pick<PointInstanceRenderer, 'buildRetainedPacked'>>;
+/** Style resolution (used only once, at build time) */
+export type RetainedStyleResolver = Pick<FeatureDrawer, 'getPointStyle' | 'getLineStringStrokeStyle' | 'getPolygonStyles'>;
+/**
+ * The set of renderers needed for retained-mode rendering
+ */
+export interface RetainedRendererSet {
+    /** Lines (only solid ones are used, since dashed polygon outlines go to immediate mode) */
+    line: RetainedLineRenderer;
+    /** Polygons (fill + solid outline) */
+    polygon: RetainedPolygonRenderer;
+    /** Points (instanced circles, squares, triangles and stars) */
+    point: RetainedPointRenderer;
+    /** Style resolution */
+    styles: RetainedStyleResolver;
+    /** Pixel size of the render target [width, height] */
+    viewport(): [number, number];
+}

package/dist/view/renderers/retained.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/view/renderers/stroke.d.ts

@@ -0,0 +1,121 @@
+/**
+ * StrokeRenderer
+ *
+ * A renderer that draws lines with thickness using triangle strips.
+ * It uses the same HHAA scheme as SDFLineRenderer.
+ * Normals are computed in screen space to achieve a uniform line width.
+ */
+import type { Map as MapLibreMap, ProjectionData } from 'maplibre-gl';
+import type { StrokeStyle } from '../../shared/types/style.js';
+import type { PixelRatioInput } from '../../shared/utils/pixel-ratio.js';
+import type { OffsetUniforms, ShaderData } from '../shaders/helpers.js';
+import { TerrainContext } from '../terrain/context.js';
+import type { WidthUnit } from './line/line-types.js';
+export type { Color, LineStyle, StrokeStyle } from '../../shared/types/style.js';
+export type { WidthUnit };
+/**
+ * The stroke options
+ */
+export interface StrokeOptions {
+    widthUnit: WidthUnit;
+    closed: boolean;
+    /**
+     * Whether to look up the ground elevation on the CPU for each point of the path
+     * and place the point on it
+     *
+     * The lines of the selection UI (the selection box and the connecting lines) set
+     * this. The elevation then comes from the same function as the handles, so the
+     * drawn line and the position that can be grabbed match structurally.
+     */
+    followTerrain?: boolean;
+    /**
+     * The elevation (in meters) to place the path on. When omitted, the ground
+     * elevation is looked up from the DEM
+     *
+     * A "single plate enclosing the feature", such as a selection box, twists in
+     * space if a different height is picked up for each vertex, and in a tilted
+     * view it appears far away from the feature. Placing it on a single height
+     * keeps it a flat plate.
+     */
+    elevationMeters?: number;
+}
+/**
+ * StrokeRenderer
+ */
+export declare class StrokeRenderer {
+    private map;
+    private gl;
+    /** The injected rendering ratio (when not injected, it is read from window each time) */
+    private pixelRatio;
+    /** The terrain state of the draw instance this renderer belongs to */
+    private readonly terrain;
+    private program;
+    private variantName;
+    private projectionUniformManager;
+    private colorLoc;
+    private dashArrayLoc;
+    private dashEnabledLoc;
+    private widthLoc;
+    private viewportLoc;
+    private miterLimitLoc;
+    private explicitElevationLoc;
+    private offsetUniforms;
+    private vao;
+    private vertexBuffer;
+    constructor(map: MapLibreMap, gl: WebGL2RenderingContext, pixelRatio?: PixelRatioInput, terrain?: TerrainContext);
+    /**
+     * Set up the vertex attributes on the VAO
+     *
+     * The structure of the vertex data: lng, lat, prevLng, prevLat, nextLng, nextLat, side, distance
+     * (8 floats = 32 bytes)
+     */
+    private setupVAO;
+    /**
+     * Make sure the shader exists (recreating it when necessary)
+     */
+    ensureShader(shaderData: ShaderData): void;
+    /**
+     * Set the uniforms for offset mode
+     */
+    setOffsetUniforms(uniforms: OffsetUniforms): void;
+    /**
+     * Create the shader program (offset mode)
+     *
+     * The same HHAA scheme as SDFLineRenderer:
+     * 1. Project the current, previous and next vertices into clip space
+     * 2. Compute the direction vectors in screen space and derive the normals
+     * 3. Miter computation
+     * 4. Apply the offset in screen space
+     * 5. Antialiasing in the fragment shader
+     */
+    private createShaderProgram;
+    /**
+     * Set the projection uniforms (supports offset mode and globe mode)
+     * @param projectionData MapLibre's ProjectionData
+     * @param zoom The current zoom level (used to switch offset mode)
+     */
+    private setProjectionUniforms;
+    /**
+     * Convert the width into pixels
+     * When widthUnit is meters, it is converted into pixels based on the zoom level and the latitude
+     * On high-DPI displays it is converted into physical pixels, taking devicePixelRatio into account
+     */
+    private getWidthInPixels;
+    /**
+     * Generate the vertex data of a line (triangle strip)
+     * Each vertex carries the information of the previous and next vertices
+     */
+    private generateVertices;
+    /**
+     * Draw a line
+     */
+    draw(coords: Array<[number, number]>, style: StrokeStyle, options: StrokeOptions, zoom: number, projectionData?: ProjectionData): void;
+    /**
+     * Draw a closed path (such as the outer ring of a polygon)
+     */
+    drawClosed(coords: Array<[number, number]>, style: StrokeStyle, options: Omit<StrokeOptions, 'closed'>, zoom: number, projectionData?: ProjectionData): void;
+    /**
+     * Dispose of the resources
+     */
+    dispose(): void;
+}