@rig-c/play 0.0.0-stage → 1.8.0

package/dist/CanvasRenderer.d.ts

@@ -0,0 +1,154 @@
+import type { PosedFrame } from './posedFrame.js';
+/** What actually drew the last frame of a `CanvasRenderer`. */
+export type CanvasBackend = 'webgl' | 'canvas2d';
+/** A rectangle of world space, Y up: `x`, `y` is its bottom-left corner. */
+export interface CanvasViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Renders a posed frame (`PosedFrame`) into **one `<canvas>`** — the canvas
+ * render mode, beside the DOM tier (`DomRenderer`) and with the same
+ * `render(frame)` interface.
+ *
+ * Every slot is drawn as textured triangles straight from its atlas page — a
+ * region as two triangles over its four corners and its page UVs, a mesh as its
+ * own triangles — through the **shared module-level WebGL context** of the mesh
+ * blitter (`MeshGlBlitter.ts`), into one rect of its offscreen buffer, and the
+ * rect is copied onto this renderer's visible canvas with one `drawImage`. No
+ * context is created per renderer, so any number of players draw under the
+ * browser's ~16-context cap, and the page textures are shared and
+ * reference-counted with every other renderer on the page.
+ *
+ * - **Tint** (slot × attachment × the player's colour) is a vertex colour,
+ *   premultiplied by its alpha; the **dark** (two-colour) tint is a second
+ *   vertex colour, carried only when some slot of the frame has one.
+ * - **Blend** is batch state: a run of triangles ends wherever the page or the
+ *   blend mode changes (`drawCalls`, and `blendFlushes` for the blend changes).
+ *   The blends are composed inside this canvas's own rect, which starts
+ *   transparent — an additive or multiply slot meets the slots under it, not
+ *   the page behind the canvas.
+ * - **Clipping** is the core's cut: every triangle a clip covers goes through
+ *   `clipThrough` from `rig-c/core` (convex polygons by the runtime's measured
+ *   rule, concave ones into convex pieces, inverse clips as the hull's
+ *   outside). No stencil, no `clip-path`.
+ * - **Projection**: the canvas covers a rect of the root's own coordinates
+ *   (world x, world −y — the DOM tier's frame), so a world point lands at
+ *   `((x − left) · pixelRatio, (−y − top) · pixelRatio)` device px. That rect
+ *   is the caller's `viewport` when set, and otherwise grows to cover what the
+ *   frames draw (grow-only, so steady animation reallocates nothing).
+ * - **Dirty-skip**: a frame whose record equals the last one drawn — vertex
+ *   arrays, tints, order, clips, pages — draws nothing (`framesReused`).
+ *
+ * When WebGL is unavailable or the shared context is lost, the frame is drawn
+ * on the same visible canvas with canvas2d: regions by `drawImage` under their
+ * affine, meshes and clipped pieces by the DOM tier's per-triangle mapping.
+ * That fallback multiplies **alpha only** — RGB and dark tints are not drawn
+ * there (`ctx.filter` is not available on Safari) — and it is a safety net,
+ * not the measured path.
+ */
+export declare class CanvasRenderer {
+    private readonly root;
+    private readonly pages;
+    /**
+     * Backing-store pixels per root CSS pixel; defaults to the device pixel
+     * ratio. A root under a CSS-scaled ancestor rasters at the wrong resolution
+     * until the scale is folded in — `syncPixelRatio()` measures it, as for the
+     * DOM tier. The next `render` sizes the backing store to the new ratio.
+     */
+    pixelRatio: number;
+    /** Apply the clips the frame carries (default). False draws every slot unclipped and counts the clips in `clipSkipCount`. */
+    clipping: boolean;
+    /**
+     * The world rect the canvas covers. Null (default) sizes it from the frames
+     * themselves: it grows to cover everything drawn and never shrinks. Set it to
+     * pin the canvas to a stage box; what falls outside is not drawn.
+     */
+    viewport: CanvasViewport | null;
+    /** The backend to draw with: 'webgl' (default) through the shared context, or 'canvas2d' to force the fallback. */
+    backend: CanvasBackend;
+    /** What drew the last frame (or would have, had it not been reused). */
+    backendActive: CanvasBackend;
+    /** The visible canvas — the renderer's one element in the root. */
+    readonly canvas: HTMLCanvasElement;
+    /** Draw calls issued last frame — one per run of one page under one blend. */
+    drawCalls: number;
+    /** Of those runs, how many began because the blend mode changed. */
+    blendFlushes: number;
+    /** Triangles drawn last frame, clipped pieces counted as cut. */
+    trianglesDrawn: number;
+    /** 1 when the last render() found the record unchanged and drew nothing, else 0. */
+    framesReused: number;
+    /** Blits onto the visible canvas last frame (0 or 1). */
+    blits: number;
+    /** Visible-canvas backing reallocations last frame; settles at zero. */
+    canvasReallocCount: number;
+    /** Distinct clips applied last frame. */
+    clipCount: number;
+    /** Clips in the frame not applied last frame: `clipping` off, fewer than three points, or a polygon the core refuses to cut. */
+    clipSkipCount: number;
+    private readonly ctx;
+    /** The rect in root units the canvas covers: left, top, right, bottom (Y down). Empty until the first frame. */
+    private left;
+    private top;
+    private right;
+    private bottom;
+    private hasRect;
+    private backingW;
+    private backingH;
+    private backingRatio;
+    private data;
+    private readonly runs;
+    /** Pages retained from the shared blitter, one retain each, released by dispose(). */
+    private readonly glPages;
+    /** The dirty signature of the last frame drawn: its numbers, and the objects it compares by identity. */
+    private sig;
+    private sigLength;
+    private sigRefs;
+    private nextSig;
+    private nextRefs;
+    /**
+     * @param root Positioned element that becomes the skeleton origin, exactly as
+     *   for `DomRenderer`: the canvas is appended to it and placed in its own
+     *   coordinates; layout and scaling of the root belong to the caller.
+     * @param pages Page images keyed by page name — `PosedRegion.page` and
+     *   `PosedMesh.page`. Read on every draw.
+     */
+    constructor(root: HTMLElement, pages: ReadonlyMap<string, HTMLImageElement>);
+    /** Grows the automatic viewport to cover `box` (world units, Y up) ahead of the frames reaching it. */
+    /**
+     * Measures the root's effective on-screen scale and sets `pixelRatio` to
+     * `devicePixelRatio × scale`, returning the ratio now in effect — the same
+     * call, the same meaning and the same deadband as `DomRenderer`'s, so code
+     * written against `player.renderer` survives a `mode` change. One forced
+     * layout per call (a hidden box appended to the root, read, removed), which
+     * is why the renderer never calls it for you. The backing store follows on
+     * the next `render`; a root that is not laid out leaves the ratio alone.
+     */
+    syncPixelRatio(): number;
+    reserve(box: CanvasViewport): void;
+    /** Draws one frame. */
+    render(frame: PosedFrame): void;
+    /** Removes the canvas from the root and hands the pages it uploaded back to the shared blitter. Idempotent. */
+    dispose(): void;
+    private growTo;
+    private setRect;
+    /** The backing store at `rect × pixelRatio`; reallocated only when that changes. */
+    private sizeBacking;
+    /** Writes this frame's signature and compares it with the last one drawn; keeps it when it differs. */
+    private signatureChanged;
+    /** The clip counters for a reused frame — what drawing it would have counted. */
+    private countClips;
+    private stride;
+    /**
+     * The slot's triangles in world space with their page UVs — cut by the clip
+     * over it when one applies — or null when the slot draws nothing.
+     */
+    private piecesOf;
+    /** Fills `data` and `runs` for the GL path. */
+    private buildVertices;
+    private draw2d;
+}
+//# sourceMappingURL=CanvasRenderer.d.ts.map

package/dist/CanvasRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasRenderer.d.ts","sourceRoot":"","sources":["../src/CanvasRenderer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAwB,UAAU,EAAa,MAAM,iBAAiB,CAAC;AAEnF,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,CAAC;AAEjD,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,cAAc;IAqEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IArExB;;;;;OAKG;IACH,UAAU,SAA+D;IACzE,6HAA6H;IAC7H,QAAQ,UAAQ;IAChB;;;;OAIG;IACH,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAQ;IACvC,mHAAmH;IACnH,OAAO,EAAE,aAAa,CAAW;IACjC,wEAAwE;IACxE,aAAa,EAAE,aAAa,CAAW;IACvC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAEnC,8EAA8E;IAC9E,SAAS,SAAK;IACd,oEAAoE;IACpE,YAAY,SAAK;IACjB,iEAAiE;IACjE,cAAc,SAAK;IACnB,oFAAoF;IACpF,YAAY,SAAK;IACjB,yDAAyD;IACzD,KAAK,SAAK;IACV,wEAAwE;IACxE,kBAAkB,SAAK;IACvB,yCAAyC;IACzC,SAAS,SAAK;IACd,gIAAgI;IAChI,aAAa,SAAK;IAElB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;IACtD,gHAAgH;IAChH,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,sFAAsF;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,yGAAyG;IACzG,OAAO,CAAC,GAAG,CAAyB;IACpC,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,QAAQ,CAAiB;IAEjC;;;;;;OAMG;gBAEgB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAgB/D,uGAAuG;IACvG;;;;;;;;OAQG;IACH,cAAc,IAAI,MAAM;IAKxB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAIlC,uBAAuB;IACvB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAuD/B,+GAA+G;IAC/G,OAAO,IAAI,IAAI;IAYf,OAAO,CAAC,MAAM;IAkBd,OAAO,CAAC,OAAO;IAUf,oFAAoF;IACpF,OAAO,CAAC,WAAW;IAkBnB,uGAAuG;IACvG,OAAO,CAAC,gBAAgB;IAoExB,iFAAiF;IACjF,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,MAAM,CAAa;IAE3B;;;OAGG;IACH,OAAO,CAAC,QAAQ;IA4BhB,+CAA+C;IAC/C,OAAO,CAAC,aAAa;IAmErB,OAAO,CAAC,MAAM;CAmEf"}

package/dist/DomRenderer.d.ts

@@ -0,0 +1,349 @@
+import { type RegionImage } from './DomTexture.js';
+import type { PosedFrame } from './posedFrame.js';
+/** Rasterizer used for the mesh (deform) tier. */
+export type MeshBackend = 'canvas2d' | 'webgl';
+/**
+ * Renders a posed frame (`PosedFrame`) as DOM, split by slot kind:
+ *
+ * - Region slots (rigid parts) become one absolutely-positioned <img>
+ *   posed with a single CSS matrix() write per frame — exact, since bone
+ *   transforms are affine.
+ * - Mesh slots (deform parts) each get a small per-part <canvas> sized
+ *   to the mesh's world bounding box, redrawn per frame — either with the
+ *   standard per-triangle clip+transform+drawImage mapping (default), or via
+ *   a shared offscreen WebGL canvas that rect-blits into the same per-part
+ *   canvases (meshBackend = 'webgl'). Frames where the canvas-space vertices
+ *   are unchanged reuse the previous raster on both backends.
+ *
+ * Both element kinds share one stacking context, so draw order interleaves
+ * freely via z-index (rear hair canvas < torso img < front hair canvas).
+ * The RGB tint the frame carries (slot × attachment × the player's colour) is
+ * applied per element with an SVG feColorMatrix reference filter — exact
+ * channel multiply, works the same on <img> and <canvas>. Dark (two-color)
+ * tint is not expressible that way and is unsupported. A clip the frame
+ * carries becomes a CSS clip-path per element, in that element's own local
+ * frame (see `clipping`) — which slots a clip covers is decided by the poser's
+ * adapter (`frameOf`), not here.
+ *
+ * Coordinate mapping: the frame is world space, Y-up; CSS is Y-down — world Y
+ * is negated. The poser computes everything (bones, constraints, physics,
+ * deformed vertices) on the CPU; this class only draws.
+ */
+export declare class DomRenderer {
+    private readonly root;
+    private readonly regionImages;
+    private readonly pages;
+    /**
+     * Apply the clips the frame carries (default). Each element drawn inside a
+     * clip gets a CSS `clip-path` in its own local frame — an element-level
+     * feature, so both mesh backends see exactly the same thing and neither
+     * raster path knows clipping exists.
+     *
+     * Which slots a clip covers is the frame's, decided by the adapter on the
+     * runtime's semantics (`clipCover` in posedFrame.ts: one clip in force at a
+     * time, a second one met while one is in force ignored, a clip covering the
+     * slots after its own through its end slot inclusive, an end slot that is
+     * the clip's own slot — or one already passed — never ending it). A clip
+     * that covers every slot of the frame is the whole-skeleton clip, and it
+     * takes a fast path: one `clip-path` on the root instead of one per element.
+     * The root is the caller's element, so its inline `clip-path` is borrowed —
+     * saved on the first write and restored when the clip stops covering the
+     * frame, when `clipping` goes false, and by `dispose()`.
+     *
+     * False restores the pre-0.6 behaviour: clips are counted in clipSkipCount
+     * and nothing is clipped, with any clip-path this renderer wrote removed.
+     */
+    clipping: boolean;
+    /** Clips applied last frame — distinct clip polygons over the drawn slots. */
+    clipCount: number;
+    /**
+     * Clips in the frame NOT applied last frame: `clipping` is false, or the
+     * polygon has fewer than three points. A clip the runtime itself ignores (a
+     * second one met while one is in force, one on an inactive bone) never
+     * reaches the frame, so it is not counted here.
+     */
+    clipSkipCount: number;
+    /**
+     * `clip-path` style writes performed last frame, across slot elements and
+     * the root, clears included. A static polygon over static elements settles
+     * at zero: every clip-path is cached per element exactly as `transform` is.
+     */
+    clipWriteCount: number;
+    /** Mesh canvases rasterized last frame. */
+    meshCount: number;
+    /** Mesh canvases that reused their previous raster last frame. */
+    meshReuseCount: number;
+    /**
+     * Mesh canvas backing stores (re)allocated last frame. Should drop to zero
+     * once an animation reaches its steady state; a persistent nonzero value
+     * means GPU surfaces are being recreated per frame (a Safari killer).
+     */
+    canvasReallocCount: number;
+    /** Triangles rasterized last frame. */
+    triangleCount: number;
+    /**
+     * How far (px) each triangle's clip polygon is expanded from its centroid.
+     * Closes antialiased-clip cracks between adjacent triangles (Safari);
+     * set to 0 to see them.
+     */
+    triangleExpand: number;
+    /**
+     * Mesh-canvas backing-store pixels per CSS pixel. Defaults to the device
+     * pixel ratio. If the caller scales the root element, fold that scale in
+     * (e.g. devicePixelRatio * rootScale) so the raster matches the on-screen
+     * resolution instead of over- or under-sampling — syncPixelRatio() measures
+     * that scale and folds it in for you.
+     */
+    pixelRatio: number;
+    /**
+     * Rasterizer for the mesh (deform) tier. 'canvas2d' (default) maps each
+     * triangle with clip+transform+drawImage directly on the per-part canvas.
+     * 'webgl' rasterizes every dirty mesh into one shared offscreen WebGL
+     * canvas and rect-blits each mesh back onto its per-part canvas — the DOM
+     * structure and all element-level behavior (z-index interleave, tint
+     * filter, mix-blend-mode, dirty-skip) are identical, only the raster step
+     * changes. Motivation: Safari antialiases canvas2d clip paths, so the
+     * per-triangle clip mapping pays a per-triangle AA-mask cost in the GPU
+     * process that rAF-limits heavy scenes; GL rasterizes shared edges
+     * seamlessly (no clip, no crack overdraw) and the blit is an unclipped
+     * rect copy. Falls back to 'canvas2d' when WebGL is unavailable or the
+     * shared context is lost — see meshBackendActive.
+     */
+    meshBackend: MeshBackend;
+    /** Backend that actually rasterized the mesh tier during the last render(). */
+    meshBackendActive: MeshBackend;
+    private readonly views;
+    /** Counts render() calls: the stamp a view drawn this frame carries (`SlotView.drawnIn`). */
+    private frameNumber;
+    private readonly pendingJobs;
+    private readonly pendingViews;
+    /**
+     * Atlas page images this renderer has retained from the shared blitter,
+     * one retain each. Allocated on the first webgl mesh job, so a renderer
+     * that never leaves canvas2d holds nothing and gives nothing back.
+     */
+    private glPages;
+    /**
+     * World vertices copied out of the frame. Float32, as the rigid and mesh
+     * paths have always read them: the raster, the dirty signature and the
+     * clip-path quantization below are calibrated on single-precision
+     * coordinates, and the frame's doubles are rounded here once rather than
+     * changing what those paths see.
+     */
+    private scratchVertices;
+    private tintDefs;
+    /** The clip whose polygon is loaded in `clipPolygon`, if any. */
+    private clipActive;
+    /** The clips counted so far this frame, applied or skipped — one count each. */
+    private readonly clipsSeen;
+    private clipInverse;
+    /** True while the active clip is served by one clip-path on the root. */
+    private clipOnRoot;
+    /** The active clip polygon in CSS space (Y already negated), flat x,y. */
+    private clipPolygon;
+    private clipPolygonLength;
+    /**
+     * The root's inline `clip-path` before this renderer borrowed it; null means
+     * not borrowed. The root belongs to the caller, so the fast path gives back
+     * exactly the string it found.
+     */
+    private rootClipSaved;
+    /** Last clip-path string written to the root, to skip no-op style writes. */
+    private rootClipWritten;
+    /**
+     * @param root Positioned element (e.g. position:absolute) that becomes the
+     *   skeleton origin. The renderer only appends slot elements to it — layout
+     *   and scaling of the root belong to the caller.
+     * @param regionImages Unpacked per-region bitmaps (for the rigid tier),
+     *   keyed by region name — `PosedRegion.region`.
+     * @param pages Page images (for the mesh tier), keyed by page name —
+     *   `PosedMesh.page`. Read on every mesh draw, so a caller may fill it after
+     *   construction.
+     */
+    constructor(root: HTMLElement, regionImages: ReadonlyMap<string, RegionImage>, pages?: ReadonlyMap<string, HTMLImageElement>);
+    /**
+     * Backing-store pixels currently allocated across the mesh canvases
+     * (Σ width × height). Computed on demand from the views — nothing is
+     * tracked per frame — so reading it is cheap but not free; the demo reads it
+     * with the other counters, twice a second.
+     *
+     * This is the quantity `pixelRatio` moves quadratically, and the one that
+     * makes an oversampling stage visible before the frame rate does: a root
+     * scaled down by CSS without that scale folded into `pixelRatio` holds
+     * 1/scale² of the backing it needs. Hidden slots are included — their
+     * canvases keep their allocation.
+     */
+    get meshBackingPixels(): number;
+    /**
+     * Re-derives `pixelRatio` from the root's effective on-screen scale, so the
+     * mesh tier rasters at the resolution the screen actually shows.
+     *
+     * Mesh canvases are sized in the root's own coordinates, and a CSS transform
+     * anywhere above the root — the natural way to build a pan/zoom stage is
+     * `transform: scale(zoom)` on an ancestor — rescales them on screen without
+     * the renderer seeing it. At zoom z the raster is then oversampled by 1/z per
+     * axis, 1/z² in backing pixels: GPU memory and fill rate, not correctness.
+     * This folds the measured scale in, `devicePixelRatio × scale`.
+     *
+     * One layout read per call. The root itself is usually 0×0 (slot elements are
+     * absolutely positioned and posed by transforms), so there is no box to
+     * measure: a hidden 100×100 px child is appended, measured once with
+     * getBoundingClientRect(), and removed again — nothing of it is left behind.
+     * It cannot disturb the slot elements either: they interleave by z-index,
+     * which applyCommon() writes explicitly on every visible one, so DOM order is
+     * not what orders them; and the probe is `visibility: hidden` and gone before
+     * anything can paint.
+     *
+     * The scale is the larger axis of the measured box. An ancestor rotation
+     * inflates that axis-aligned box, so the ratio errs high — the safe side:
+     * oversampling costs pixels, undersampling costs picture.
+     *
+     * A move smaller than 0.1% (see PIXEL_RATIO_DEADBAND) changes nothing, and a
+     * root that is not laid out (a `display: none` ancestor — the probe measures
+     * 0) changes nothing either. Both matter because writing `pixelRatio`
+     * reallocates every mesh canvas on the next frame.
+     *
+     * The renderer never calls this itself. It is a forced synchronous layout,
+     * which has no business in a render path — and there is no per-frame layout
+     * read anywhere in this class. Call it when a zoom or a layout settles: after
+     * a wheel/pinch gesture ends, on a debounced resize, not during the drag.
+     *
+     * @returns the pixel ratio now in effect (the current one if nothing moved).
+     */
+    syncPixelRatio(): number;
+    /**
+     * Draws one frame. Slots the frame does not carry — no attachment, a
+     * clipping attachment, an inactive bone, a kind the DOM tier does not draw —
+     * are hidden, their elements kept for when they draw again.
+     */
+    render(frame: PosedFrame): void;
+    /**
+     * Removes every element this renderer added to the root (slot elements and
+     * the tint filter defs), restores the root's own inline `clip-path` if the
+     * whole-skeleton clip path borrowed it, and hands the atlas pages it
+     * uploaded back to the shared GL blitter — the one resource here that outlives the instance, so
+     * the one that has to be given back explicitly (GPU memory, and no garbage
+     * collector feels pressure from it). The pages are reference-counted there:
+     * a page another live renderer still draws stays uploaded, and the texture
+     * is deleted only when the last user of it is disposed.
+     *
+     * The region bitmaps are deliberately untouched: the map is the caller's,
+     * and one map is normally shared by many renderers (disposing one instance
+     * must not blind the others). Free the unpacked blob URLs with
+     * revokeRegions() once no renderer needs them.
+     *
+     * Idempotent: the retained-page ledger is cleared here, so a second call
+     * releases nothing a second time.
+     */
+    dispose(): void;
+    private renderRegion;
+    private renderMesh;
+    /**
+     * Declares this renderer a user of `page` with the shared blitter, once per
+     * page — the counterpart of the release in dispose(). The set is this
+     * renderer's own ledger, so sharing one page across renderers works by
+     * counting rather than by guessing. On the render path this costs one
+     * Set.has per queued mesh job and allocates nothing after the first page.
+     */
+    private retainPage;
+    /** The canvas2d raster path: clear the backing, map each triangle. */
+    private rasterizeMesh2d;
+    /**
+     * Standard canvas triangle texture mapping (same math as the official
+     * spine-canvas renderer): derive the affine that sends the triangle's
+     * texture-space corners to its screen-space corners, clip, draw the page —
+     * but only the part of the page this triangle can show (see below).
+     *
+     * The clip polygon is expanded outward from the centroid by a fraction of
+     * a pixel. Browsers that antialias clip paths (Safari) otherwise leave
+     * hairline cracks between adjacent triangles; the expanded clips overlap
+     * into the neighbouring triangle, and since the texture is continuous
+     * across the shared edge the overlap draws the same pixels — cracks close
+     * with no visible cost. The texture-mapping affine itself stays exact.
+     *
+     * ## Why a source sub-rect instead of the whole page
+     *
+     * The draw is a 9-argument `drawImage` whose source rect covers exactly what
+     * the clip can reveal, placed at the same texture-space position, so the
+     * mapping is identical to drawing the whole page — the same affine, the same
+     * texels, only fewer of them offered to the rasterizer.
+     *
+     * That is not an optimization. Linux WebKit — the software rasterizer, the
+     * only engine this has been observed on; Chromium and macOS WebKit never show
+     * it — garbles individual triangles when the whole page is drawn under a
+     * steep per-triangle affine: read off the parity dump, head/goggles/foot
+     * triangles land with displaced texture while the webgl capture of the same
+     * pose stays clean. Switching this one call to a source sub-rect — the only
+     * variable changed — took that platform's bad-pixel counts from 1042 to 2
+     * (hoverboard), 231 to 4 (portal) and 803 to 3 (walk + tint), and left every
+     * Chromium capture byte-identical. [measured on the ubuntu CI runner through
+     * PARITY_DUMP: first with a fixed 2-texel pad (run 35209262693), then with
+     * the derived rect below — the same counts (run 35213286993).] WHY that
+     * rasterizer garbles the whole-page form is not identified; steep affines
+     * making whole-page coordinates large is a suspicion, not a measurement. The
+     * sub-rect sidesteps it. (Moving `clip()` before `transform()` was tried as a
+     * separate one-variable experiment: every number came back identical, so the
+     * clip path is not the cause.)
+     *
+     * ## How the sub-rect is derived
+     *
+     * It must provably cover everything the clip can reveal, which is the
+     * *expanded* polygon, not the triangle. So each clip corner's canvas-space
+     * displacement is pushed back through the inverse of the 2×2 affine into
+     * texture space, the bounding box is taken over the displaced corners, one
+     * texel of bilinear support is added, and the result is floor/ceil'd to texel
+     * boundaries (so the sub-rect itself resamples nothing) and clamped to the
+     * page. A fixed pad would not do: the texture-space reach of the expansion is
+     * `triangleExpand` times the local texels-per-canvas-unit, which on the
+     * demo's own meshes ranges from ~0.26 texels on a typical triangle to ~8.6 on
+     * a foreshortened one. Under-padding lets the rim of the overdraw sample
+     * nothing, which brings back the very seams the overdraw exists to close.
+     *
+     * No half-texel offset is applied to the incoming u/v: the `(i + 0.5) / size`
+     * texel-centre convention belongs to *sampling* (landing inside the intended
+     * texel instead of on a filter boundary). This solves for the affine that
+     * sends three source corners to three destination corners; the rasterizer
+     * then samples continuously along that map. Biasing all three corners by
+     * half a texel would translate the texture against the geometry — the very
+     * class of offset the `uv * size` addressing removes.
+     */
+    private drawTriangle;
+    /**
+     * Makes `clip` the clip in force for the slot about to be drawn, loading its
+     * polygon when it is not the one already loaded. Each clip object is counted
+     * once per frame — in clipCount when applied, in clipSkipCount when
+     * `clipping` is off or the polygon has fewer than three points (no clip is
+     * in force then, so the slot draws unclipped, as the runtime would).
+     *
+     * The polygon is the poser's world-space one, and the only things done to it
+     * here are the single-precision read the vertex paths share and the Y
+     * negation the rest of the renderer already applies. It is NOT convexified
+     * or triangulated the way the CPU clipper does — CSS `polygon()` takes a
+     * concave polygon directly, so the decomposition that exists to feed a
+     * triangle rasterizer has no job here.
+     */
+    private useClip;
+    /**
+     * Writes (or clears) this element's clip-path. `a…f` is the element's own
+     * CSS transform, and the world polygon is carried through its INVERSE:
+     * clip-path is resolved in the element's local frame and then transformed
+     * along with the element, so the polygon has to arrive there already.
+     *
+     * `transform-origin` is `0 0` on every slot element (see view()), so the
+     * matrix maps local (0,0) to (e,f) with no origin term to undo, and
+     * `left/top: 0` puts the border box — clip-path's reference box — on that
+     * same local origin.
+     */
+    private applyClip;
+    private setClipPath;
+    /** The active polygon in the root's own frame — no element transform. */
+    private rootClipPath;
+    private writeRootClip;
+    private releaseRootClip;
+    private setTransform;
+    private applyCommon;
+    private tintMatrixFor;
+    private view;
+    private hide;
+}
+//# sourceMappingURL=DomRenderer.d.ts.map

package/dist/DomRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomRenderer.d.ts","sourceRoot":"","sources":["../src/DomRenderer.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,WAAW,EAAuB,MAAM,iBAAiB,CAAC;AAEzF,OAAO,KAAK,EAAwB,UAAU,EAAqC,MAAM,iBAAiB,CAAC;AAE3G,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC;AAiH/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,WAAW;IAmIpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IApIxB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,UAAQ;IAChB,8EAA8E;IAC9E,SAAS,SAAK;IACd;;;;;OAKG;IACH,aAAa,SAAK;IAClB;;;;OAIG;IACH,cAAc,SAAK;IACnB,2CAA2C;IAC3C,SAAS,SAAK;IACd,kEAAkE;IAClE,cAAc,SAAK;IACnB;;;;OAIG;IACH,kBAAkB,SAAK;IACvB,uCAAuC;IACvC,aAAa,SAAK;IAClB;;;;OAIG;IACH,cAAc,SAAO;IACrB;;;;;;OAMG;IACH,UAAU,SAA+D;IACzE;;;;;;;;;;;;;OAaG;IACH,WAAW,EAAE,WAAW,CAAc;IACtC,+EAA+E;IAC/E,iBAAiB,EAAE,WAAW,CAAc;IAE5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,6FAA6F;IAC7F,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkB;IAC/C;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAsC;IACrD;;;;;;OAMG;IACH,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAA8B;IAC9C,iEAAiE;IACjE,OAAO,CAAC,UAAU,CAA0B;IAC5C,gFAAgF;IAChF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,WAAW,CAAS;IAC5B,yEAAyE;IACzE,OAAO,CAAC,UAAU,CAAS;IAC3B,0EAA0E;IAC1E,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,iBAAiB,CAAK;IAC9B;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAuB;IAC5C,6EAA6E;IAC7E,OAAO,CAAC,eAAe,CAAM;IAE7B;;;;;;;;;OASG;gBAEgB,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,EAC9C,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAa;IAG3E;;;;;;;;;;;OAWG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAM9B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,cAAc,IAAI,MAAM;IAKxB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAqE/B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,IAAI,IAAI;IAiBf,OAAO,CAAC,YAAY;IAwCpB,OAAO,CAAC,UAAU;IAiJlB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB,sEAAsE;IACtE,OAAO,CAAC,eAAe;IAuCvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0DG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,OAAO;IAmCf;;;;;;;;;;OAUG;IACH,OAAO,CAAC,SAAS;IAoDjB,OAAO,CAAC,WAAW;IAOnB,yEAAyE;IACzE,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,WAAW;IA4CnB,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,IAAI;IAmDZ,OAAO,CAAC,IAAI;CAWb"}