isard 1.2.0 → 1.4.0

package/dist/workers/basemap.worker.d.ts

@@ -2,17 +2,27 @@
  * Worker of the vector basemaps: fetches and decodes vector tiles (kept for the tiles that share them), draws their
  * fills, lines and circles with a MapLibre style into images (Canvas 2D, off the main thread) for the raster pool,
  * with the style's raster layers under them, and lists the label candidates of the style's symbol layers (their texts
- * and icons) for the page to shape and place. Extrusions are drawn flat, as fills. It also decodes the altitudes of PNG relief tiles and
- * draws the rasters reprojected from other grids (planned by the page), for the map's other layers.
+ * and icons) for the page to shape and place. Extrusions are drawn flat, as fills. Or it cuts the fills, lines and
+ * buildings of a tile into geometry for the engine to draw as such (`vectors`), with their style per feature (a
+ * building's color, height and base height). It also decodes the
+ * altitudes of PNG relief tiles and draws the rasters reprojected from other grids (planned by the page), for the
+ * map's other layers.
  *
  * A raster tile of level z covers 256 CSS pixels at map zoom z - 1 (MapLibre's 512 px convention): it is drawn from
  * the vector tile of level z - 1 (or the deepest one the source has), with the style at that zoom.
+ *
+ * This module answers the page's messages; the jobs are in `./basemap/`: the state they share (`tiles.ts`), the
+ * images (`raster.ts`), the labels (`labels.ts`), the geometry (`geometry.ts`), the trees (`trees.ts`).
  */
+import type { Value } from '../basemap/mvt.ts';
 import { type Job } from '../basemap/resample.ts';
 import { type PngEncoding } from '../basemap/terrain.ts';
 import { type LabelCandidate, type RasterSource, type StyleLayer } from '../basemap/vectorstyle.ts';
 import { type HeaderRules } from '../engine/requests.ts';
-export type { LabelCandidate, RasterSource };
+import { type GridDescription, type StreetFlows } from '../grid-module.ts';
+import { type StreetWork } from './basemap/street.ts';
+import { type Sprite } from './basemap/tiles.ts';
+export type { LabelCandidate, RasterSource, Sprite };
 /** Fetch priority of a request (`fetch`'s `priority`, a hint to the browser) */
 export type Priority = 'high' | 'low' | 'auto';
 /** A tile's image or labels, asked of a worker; or a tile of another layer decoded: the altitudes of a PNG relief
@@ -35,11 +45,60 @@ export type BasemapWork = {
     y: number;
     zoom?: number;
     priority?: Priority;
+}
+/** The polygons of the renderer's layers (buildings), for extrusions */
+ | {
+    type: 'polygons';
+    key: string;
+    z: number;
+    x: number;
+    y: number;
+    priority?: Priority;
+}
+/** Trees scattered over the polygons of the renderer's layers, `spacing[s]` metres apart in layer `s` (0: none), at
+ * most `maxTrees` */
+ | {
+    type: 'trees';
+    key: string;
+    z: number;
+    x: number;
+    y: number;
+    spacing: number[];
+    maxTrees: number;
+    priority?: Priority;
+}
+/** The fills and lines of the renderer's layers cut to the tile, for the engine to draw as geometry; `styles`: their
+ * style only, the layers' paint changed (the same features, in the same order). A tile past the source's deepest
+ * level is cut from its tile of that level (overzoom); `deepest`, the deepest level asked for (default the
+ * source's), is styled past itself, as the map stretches it */
+ | {
+    type: 'vectors';
+    key: string;
+    z: number;
+    x: number;
+    y: number;
+    deepest?: number;
+    styles?: boolean;
+    /** With the prisms of the fills (a relief under them) */
+    prism?: boolean;
+    priority?: Priority;
 } | {
     type: 'heights';
     url: string;
     encoding: PngEncoding;
     floor?: number;
+}
+/** The wind of a city's streets round the buildings of the renderer's layers (see `StreetWork`) */
+ | ({
+    type: 'street';
+    key: string;
+} & StreetWork)
+/** A GRIB2 or NetCDF file (fetched from `url`, or its `bytes`) read into grids by the grid module (`module`) */
+ | {
+    type: 'grids';
+    module: string;
+    url?: string;
+    bytes?: ArrayBuffer;
 } | {
     type: 'reproject';
     job: Job;
@@ -50,6 +109,11 @@ export type BasemapRequest =
 {
     type: 'headers';
     rules: HeaderRules;
+}
+/** Where the tessellation module is (`isard_tess_bg.wasm`), loaded with the first `vectors` job */
+ | {
+    type: 'tess';
+    url: string;
 } | {
     type: 'init';
     /** Renderers by key: each draws its own layers of the same source */
@@ -86,29 +150,90 @@ export type BasemapResponse = {
 } | {
     id: number;
     labels: LabelCandidate[];
+} | {
+    id: number;
+    polygons: TilePolygons;
+} | {
+    id: number;
+    trees: Float64Array;
+} | {
+    id: number;
+    vectors: TileVectors;
+} | {
+    id: number;
+    styles: Float32Array;
 } | {
     id: number;
     heights: Float32Array;
+} | {
+    id: number;
+    grids: GridDescription[];
+    values: Float32Array[];
+} | {
+    id: number;
+    street: StreetFlows;
 };
-/** A sprite of the style: its images by name (`id:name` but in the default sprite) and its sheet */
-export interface Sprite {
-    image: ImageBitmap;
-    icons: Record<string, {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        pixelRatio?: number;
-    }>;
+/** The polygons of a tile in Mercator [0, 1], as the extrusions take them (`PolygonArrays`), and their properties */
+export interface TilePolygons {
+    arrays: {
+        points: Float64Array;
+        ringStart: Uint32Array;
+        polygonStart: Uint32Array;
+        feature: Uint32Array;
+    };
+    properties: Record<string, Value>[];
 }
-/** The decoded tiles one worker of `workers` keeps */
-export declare const cacheShare: (workers: number) => number;
 /**
- * The image of a drawn canvas, its alpha straight (the engine blends straight alpha). An opaque tile (a background
- * of full opacity, as a basemap's) is moved out of the canvas as it is, premultiplied and straight being the same
- * there; another one is read back unpremultiplied, copied
+ * The geometry of a vector tile for the engine (`setVectorTile`), in Mercator [0, 1], cut to the tile: a styled
+ * feature is a feature of the tile in one of the renderer's layers (the sublayers, in their order), numbered layer
+ * after layer. The polygons and lines of sublayer `s` are `fillStart[s] .. fillStart[s + 1]` and `lineStart[s] ..
+ * lineStart[s + 1]` (one more entry than the renderer's layers)
  */
-export declare const tileImage: (canvas: OffscreenCanvas, g: OffscreenCanvasRenderingContext2D, opaque: boolean) => Promise<ImageBitmap>;
-/** Points every `spacing` along a line (tile units, x and y interleaved), the first half a spacing in (the middle of a
- * shorter line): each point and the segment it lies on (x, y, x0, y0, x1, y1) */
-export declare const lineAnchors: (line: readonly number[], spacing: number) => number[][];
+export interface TileVectors {
+    fills: {
+        points: Float64Array;
+        ringStart: Uint32Array;
+        polygonStart: Uint32Array;
+        feature: Uint32Array;
+        fillStart: Uint32Array;
+    };
+    lines: {
+        points: Float64Array;
+        start: Uint32Array;
+        feature: Uint32Array;
+        lineStart: Uint32Array;
+    };
+    /** The style of each styled feature, `FLOATS` (32) each, as the engine's line layers take it */
+    styles: Float32Array;
+    /** The tile's corners (west, north, east, south, Mercator): no wall of a building along its edges, where one cut
+     * there goes on in the next tile */
+    tile?: Float64Array;
+    /** Its feature's properties (shared by the styled features of one feature) and its sublayer */
+    properties: Record<string, Value>[];
+    sublayer: Uint16Array;
+    /** The geometry made ready for the GPU by the tessellation module (the engine's `setVectorTileMesh`); without it,
+     * the engine does that on the main thread */
+    mesh?: TileMesh;
+}
+/** A vector tile ready for the GPU, as the tessellation module makes it (`TessellatedTile`) */
+export interface TileMesh {
+    /** Fill vertices, as bytes */
+    vertices: Uint8Array;
+    indices: Uint32Array;
+    /** Per sublayer: its top cap and the rest of its prism, first and end of each */
+    fillRanges: Uint32Array;
+    prism: boolean;
+    /** Line pieces, as bytes */
+    pieces: Uint8Array;
+    /** Feature and length of each line */
+    lineTable: Float32Array;
+    /** Per sublayer: its pieces, first and end */
+    lineRanges: Uint32Array;
+    /** Blocks of the extrusion sublayers (buildings), as bytes */
+    blocks: Uint8Array;
+    blockIndices: Uint32Array;
+    /** Per sublayer: its blocks' triangles, first and end */
+    blockRanges: Uint32Array;
+    /** Min x, min y, max x, max y of the tile's points */
+    bounds: Float64Array;
+}