@react-x11/components 0.8.0 → 0.9.0

package/dist/maps/gl/renderer.d.ts

@@ -0,0 +1,352 @@
+import type { PreparedStyle } from '../paint.js';
+import type { GlTileData } from './buckets.js';
+import type { Rgba } from './color.js';
+import type { MarkerBatch } from './markers.js';
+import type { OverlayPass } from './overlays.js';
+import type { LabelBatch } from './placement.js';
+import type { GL } from './shaders.js';
+/** A rectangle in device pixels, top-left origin. */
+export interface DeviceRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** One tile's data placed on screen. */
+export interface RenderTile {
+    data: GlTileData;
+    /** Where the data tile's square lands, in device pixels: its top-left
+     *  corner and its edge length. */
+    x: number;
+    y: number;
+    size: number;
+    /**
+     * The part of the viewport this tile draws into. Its own square, unless
+     * it is standing in for a tile that has no data yet — an ancestor scaled
+     * up, drawn only over the square it covers for.
+     */
+    clip: DeviceRect;
+}
+/** Everything a frame is drawn from. */
+export interface RenderFrame {
+    /** Device pixels. */
+    width: number;
+    height: number;
+    /** The camera zoom: what zoom ramps and layer ranges resolve at. */
+    zoom: number;
+    /** Device pixels per logical pixel: what style lengths are multiplied by. */
+    scale: number;
+    style: PreparedStyle;
+    background?: string;
+    /**
+     * Each source's tiles, in the map's order — a basemap, then a pyramid
+     * over it. Each is drawn whole, layer-major, before the next, which is
+     * how the retained renderer lays one source's tiles over another's.
+     */
+    sources: readonly (readonly RenderTile[])[];
+    /**
+     * Leave out the style layers that begin within this many levels of the
+     * zoom: a layer whose `minZoom` is above `zoom - detail` is skipped. `0`
+     * (the default) draws what the style says.
+     *
+     * The layers a style brings in last as the map zooms in are its details —
+     * buildings, service roads, paths, sites — so this drops exactly those, in
+     * that order, and it needs nothing from the style that the style has not
+     * already said.
+     */
+    detail?: number;
+    /** The fill edge pass for this frame, over the renderer's `antialias`. */
+    edges?: boolean;
+}
+/** A second scene, and how much of it to show over the first. */
+export interface FadeFrame {
+    frame: RenderFrame;
+    /** `0` shows only the base scene, `1` only this one. */
+    alpha: number;
+}
+/**
+ * The attribution: a box of the theme's background, and the text in it —
+ * one label's worth of instance data from the labels' atlas, set level and
+ * on whole pixels.
+ */
+export interface AttributionDraw {
+    /** Device pixels, top-left origin. */
+    box: DeviceRect;
+    /** Premultiplied, its opacity folded in. */
+    boxColor: Rgba;
+    text: LabelBatch;
+}
+/** The overlays' bucket, and where its units land this frame. */
+export interface OverlayDraw {
+    data: GlTileData;
+    passes: readonly OverlayPass[];
+    /** Device pixels per unit of the bucket's records. */
+    unit: number;
+    /** Where the bucket's origin lands, in device pixels. */
+    x: number;
+    y: number;
+}
+/** What a frame draws over its scene, in this order. */
+export interface RenderExtras {
+    /** A second scene, faded in over the first. */
+    fade?: FadeFrame | null;
+    /** The labels, over both. */
+    labels?: LabelBatch | null;
+    /** The overlays, over the labels — where the retained renderer draws
+     *  them. */
+    overlays?: OverlayDraw | null;
+    /** The markers, over the labels — where the retained renderer draws
+     *  them, a marker being what the user aims at. */
+    markers?: MarkerBatch | null;
+    /** The attribution, over everything — drawn last, as the retained
+     *  renderer draws it. */
+    attribution?: AttributionDraw | null;
+}
+export interface GlRenderOptions {
+    /**
+     * Draw each polygon's boundary as a half-pixel antialiased line after the
+     * fill. `true` by default. There is no multisampling on these surfaces
+     * (x11-dri exposes no `renderbufferStorageMultisample`), so without it a
+     * fill's edge is a staircase; this is the same trade MapLibre's
+     * `fill-antialias` makes.
+     */
+    antialias?: boolean;
+    /**
+     * `'nonzero'` (the default) is the rule the retained renderer fills with,
+     * and costs two stencil passes, one per facing — or one, on a GL table
+     * with `stencilOpSeparate` (x11-dri 0.8, and the Cocoa backend's), which
+     * counts both facings in the same draw. `'evenodd'` is one pass —
+     * and wrong wherever two features of one layer overlap, which real
+     * landuse does: the overlap is cut out as if it were a hole.
+     */
+    fillRule?: 'nonzero' | 'evenodd';
+    /**
+     * Draw into an offscreen framebuffer and copy it to the surface. `'auto'`
+     * (the default) does that only when the surface has no stencil buffer —
+     * which is XQuartz's Apple-DRI surface today, whose context ntk creates
+     * without one.
+     */
+    offscreen?: 'auto' | boolean;
+}
+/** What one frame cost, and what it drew. */
+export interface GlRenderStats {
+    tiles: number;
+    layers: number;
+    drawCalls: number;
+    /** Segment instances drawn, every pass counted — the frame's work. */
+    instances: number;
+    /** Tiles uploaded this frame, and their bytes. */
+    uploads: number;
+    uploadBytes: number;
+    /** Milliseconds on this thread issuing the frame — not the GPU's time. */
+    cpuMs: number;
+    offscreen: boolean;
+    /** How much of a second scene was faded in; `0` when there was none. */
+    fade: number;
+    /** Labels drawn. */
+    labels: number;
+    /** Markers drawn. */
+    markers: number;
+    /** Overlay passes drawn — a line with a casing is two. */
+    overlays: number;
+}
+/**
+ * A style's or an overlay's dash array as the line program draws it: in
+ * device pixels, and read as a canvas reads one — an odd number of entries
+ * is repeated to make an even one, and an entry that is negative or not a
+ * number, or entries that are all zero, make a solid line. A pattern of
+ * more than four dashes is cut to its first four.
+ */
+export declare function dashPattern(dash: readonly number[] | undefined, scale: number): number[] | null;
+export declare class GlMapRenderer {
+    private readonly _gl;
+    private readonly _options;
+    private readonly _line;
+    private readonly _fan;
+    private readonly _cover;
+    private _blit;
+    private readonly _corners;
+    private readonly _coverVao;
+    private readonly _tiles;
+    private readonly _colors;
+    private _stencil;
+    /** Whether the table sets each facing's stencil operation apart, which
+     *  makes the non-zero winding one pass. */
+    private readonly _separate;
+    /** Offscreen targets by role: `'output'` stands in for a surface with no
+     *  stencil buffer, `'fade'` holds the scene being faded in. */
+    private readonly _targets;
+    /** The label pass: its program, its instance buffer and the vertex array
+     *  over it, and the atlas texture with the atlas generation it holds. */
+    private _label;
+    private _labelVao;
+    private _labelBuffer;
+    private _marker;
+    private _markerVao;
+    private _markerBuffer;
+    private _circle;
+    private _raster;
+    private _atlasTexture;
+    private _atlasOwner;
+    private _stats;
+    /** Bytes of tile geometry resident on the GPU. */
+    gpuBytes: number;
+    constructor(gl: GL, options?: GlRenderOptions);
+    set antialias(on: boolean);
+    set fillRule(rule: 'nonzero' | 'evenodd');
+    private static _emptyStats;
+    /**
+     * What a frame would cost, in the unit `stats.instances` counts — segment
+     * instances, every pass included — without drawing it. The same gates the
+     * frame itself applies, over the ranges' record counts, so it is a walk of
+     * a few hundred numbers: cheap enough to price several versions of the
+     * next frame and draw the one that fits.
+     */
+    estimate(frame: RenderFrame): number;
+    /**
+     * Draw a frame into whatever framebuffer is bound — and, given `fade`, a
+     * second scene over it at `fade.alpha`, and given `labels`, the labels
+     * over both.
+     *
+     * The second scene is drawn whole into an offscreen target and composited
+     * once, rather than layer by layer at reduced opacity: a map faded layer
+     * by layer shows its casings through its fills and its water through its
+     * land. Both scenes are opaque, so the composite is exactly a cross-fade.
+     * Labels go on after it, at full strength: they are placed for the view,
+     * not for either level, and a name that dimmed with the level it came
+     * from would blink at every level change.
+     */
+    render(frame: RenderFrame, extras?: RenderExtras): GlRenderStats;
+    /** Drop one tile's buffers. */
+    release(data: GlTileData): void;
+    /** Whether a tile's buffers are resident. */
+    resident(data: GlTileData): boolean;
+    dispose(): void;
+    /** The whole style, into the bound framebuffer, from a clear. */
+    private _scene;
+    private _fill;
+    /**
+     * A polygon's ranges, over every tile that has them: the winding number
+     * into the stencil buffer, the colour wherever it is not zero, then the
+     * edge — the antialiasing, or an outline.
+     */
+    private _fillWith;
+    private _lines;
+    /**
+     * A circle layer: a disc per point, one instanced draw per tile — the
+     * radius, colours and stroke `paint.ts` reads, at this zoom.
+     */
+    private _circles;
+    /**
+     * A raster source's tiles: each one's image over its square, clipped to
+     * the part of the view it draws. Past the source's depth the square is
+     * the data tile's, larger than the view's cells, so the image is drawn
+     * whole and stretched — the retained renderer's rule since #98.
+     */
+    private _rasters;
+    /**
+     * A stroke of one layer's ranges — of the line stream, or of the fill
+     * stream as a polygon's outline. A translucent one is drawn each pixel
+     * once: two capsules overlap at every join, and colour laid down twice
+     * there is a darker bead at every vertex. So the pixels a capsule covers
+     * wholly go first, under the stencil, the first capsule to reach one
+     * taking it; then the antialiased fringe, where nothing has been yet.
+     */
+    private _strokeWith;
+    /** One layer's ranges as capsules, over every tile that has them. `part`
+     *  1 draws only the pixels a capsule covers wholly, 2 only the rest, and
+     *  0 both. */
+    private _segments;
+    /** The union of the squares a layer draws in, as a scissor box; null
+     *  when no tile draws it. */
+    private _unionOf;
+    /** The stencil back to zero over a box, the colour untouched. */
+    private _clearStencil;
+    /**
+     * The overlays, over the labels — the retained renderer's order — from
+     * their bucket, placed this frame, pass by pass: a fill as a style's fill
+     * layer is drawn, a stroke as its line layer is. Answers how many passes
+     * it drew.
+     */
+    private _overlays;
+    /**
+     * Every tile's ranges for one layer: scissor, place, draw. The loop the
+     * whole frame is made of, so it allocates nothing and sets only what
+     * changes between tiles.
+     */
+    private _eachTile;
+    /**
+     * The attribution, over whatever is bound: its box — the cover program,
+     * scissored to it — and then its text, one more label quad.
+     */
+    private _attribution;
+    /**
+     * A batch of labels, over whatever is bound: one instanced draw of the
+     * batch's quads, after the atlas texture has what the batch draws.
+     * Answers how many it drew.
+     */
+    private _labels;
+    /**
+     * The markers, over whatever is bound: one instanced draw of a quad each,
+     * every pixel shaded by its distance to the marker's outline. Answers how
+     * many it drew.
+     */
+    private _markers;
+    /**
+     * Take what the atlas has waiting into the texture — a few dozen rasters
+     * a frame at most, so a batch landing is spread over frames rather than
+     * paid in one. A texture that is new, or another atlas's, starts over:
+     * the atlas queues everything again. Leaves the texture bound.
+     *
+     * The rasters go up as the text engine read them back — straight RGBA,
+     * white where the glyphs are — because the shader reads only alpha:
+     * premultiplying them first was a pass over every pixel for nothing.
+     */
+    private _uploadAtlas;
+    private _color;
+    private _gpu;
+    /**
+     * The vertex array for a range: the corner quad per vertex, and records
+     * `first`, `first + 1` (and the third attribute) per instance.
+     *
+     * One per range because instanced attributes ignore `first` — GL 4.1 and
+     * ES 3.0 have no base instance — so the range's start is baked into the
+     * attribute offsets instead. A tile has one range per style layer it
+     * draws, so this is two dozen small objects per tile, made once.
+     */
+    private _vao;
+    private _drawCover;
+    /**
+     * Does the bound framebuffer have a stencil buffer? Asked by drawing
+     * rather than by querying, because the query differs between the default
+     * framebuffer of a core profile (where `STENCIL_BITS` is gone) and a
+     * user one, and the Cocoa surface is the second while XQuartz's is the
+     * first. Two pixels, one read-back, on the first frame only.
+     *
+     * Both halves are needed, and the first version had only the second: **a
+     * framebuffer with no stencil buffer passes every stencil test**, so "write
+     * 1, then draw where it is 1" draws either way and cannot tell the two
+     * apart. XQuartz's surface — which has none — answered yes, the frame went
+     * straight to it, and every fill's cover pass painted the whole view in
+     * that layer's colour. So pixel 0 asks the question that only a real
+     * buffer answers "no" to: a draw where a *cleared* stencil is not zero.
+     */
+    private _probeStencil;
+    /** An offscreen colour target with its own stencil, made or remade at
+     *  this size. Leaves its framebuffer bound. */
+    private _target;
+    /** An offscreen target onto the bound framebuffer: a copy at `alpha` 1,
+     *  a cross-fade below it. */
+    private _composite;
+    private _dropTarget;
+}
+/**
+ * A clip rectangle as a GL scissor box: whole pixels, bottom-left origin,
+ * clamped to the viewport, or null when nothing of it is visible.
+ *
+ * Rounded edge by edge rather than origin-and-size, so two tiles that share
+ * an edge round it to the same pixel column and neither a gap nor a double
+ * row can open between them at any fractional zoom.
+ */
+export declare function scissorOf(clip: DeviceRect, width: number, height: number): number[] | null;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/maps/gl/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/maps/gl/renderer.ts"],"names":[],"mappings":"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"}