@rig-c/play 0.0.0-stage → 1.8.0

package/dist/DomTexture.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Where one region sits on its page — the fields of a model document's
+ * `pages[].regions[]` entry (`ModelPageRegion` in rig-c) that a cut reads.
+ * `width` and `height` are the artwork's own, unrotated: a region packed at
+ * `degrees: 90` occupies a `height × width` rect on the page.
+ */
+export interface PageRegion {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    degrees: number;
+}
+/**
+ * One page of the layout `unpackRegions` cuts from — a model document's
+ * `pages[]` entry. `width`/`height` are the page's *declared* size (the atlas
+ * `size:` line the build wrote), not necessarily the image's.
+ */
+export interface PageLayout {
+    name: string;
+    width: number;
+    height: number;
+    /** Whether the page's texels are premultiplied by their alpha (absent: false). */
+    pma?: boolean;
+    regions: readonly PageRegion[];
+}
+export interface RegionImage {
+    /**
+     * URL of the unpacked (rotation-restored) region pixels: a blob URL minted
+     * by unpackRegions, the page image URL itself when the region covers its
+     * whole page, or anything the caller put there in a hand-built map.
+     */
+    url: string;
+    /**
+     * Unpacked width in **atlas units** — the region's own `width`, not the
+     * bitmap's pixel width. The two differ whenever the page image ships at a
+     * resolution its atlas `size:` line does not mention (see cutRegion): a
+     * half-resolution page yields a bitmap half this wide. This is the layout
+     * box the rigid tier writes onto its `<img>` and the denominator of the CSS
+     * matrix it builds, so it stays in the frame the skeleton is authored in
+     * and the browser scales the bitmap into it — the same thing a GPU does
+     * when it samples normalized UVs from a texture of any resolution.
+     */
+    width: number;
+    /** Unpacked height in atlas units — see `width`. */
+    height: number;
+}
+/**
+ * Page pixels in the alpha convention a DOM/canvas2d consumer needs: the page
+ * image itself, or the derived canvas below when the page is premultiplied.
+ */
+export type PageSource = HTMLImageElement | HTMLCanvasElement;
+/**
+ * How many straight-alpha page derivations have been built in this document.
+ *
+ * Deterministic (no GC in the path) and monotonic, so a test reads it before
+ * and after and asserts the *difference*. Exported for the tests only — it is
+ * not re-exported from index.ts and the `exports` map denies deep imports, so
+ * it is not package API. (The same arrangement as `liveTextureCount` on the GL
+ * blitter, and for the same reason: a cache that works is invisible.)
+ */
+export declare function straightAlphaDerivations(): number;
+/**
+ * The page as a straight-alpha source: the image itself when `pma` is false,
+ * otherwise its (cached) un-premultiplied derivation.
+ *
+ * `rgb = round(rgb * 255 / a)`, clamped, with `a === 0` left at (0,0,0,0) —
+ * there is no colour to recover from a fully transparent texel.
+ *
+ * **Precision.** The division is done in 8 bits and cannot be done anywhere
+ * else: a 2D canvas stores premultiplied colour, so `getImageData` hands back
+ * `round(round(u * a / 255) * 255 / a)` for a file value `u`, already quantized
+ * by the read (measured on both engines: put→get moves a value by up to 127 at
+ * a = 1). The colour a low-alpha texel composites to is therefore off by at
+ * most ~min(a, 127.5/a + 0.5) of 255 — nothing at a = 255 or a = 0, ≤ 1 above
+ * a = 128, worst ~12 around a = 11, and bounded by `a` below that. Writing the
+ * values back is exact, not a second premultiply: the canvas quantizer is
+ * idempotent, so putting a value that came out of it stores it unchanged
+ * (measured: a second round trip moves nothing on either engine). The remaining
+ * error is one-way rounding on near-invisible texels, against a defect that
+ * darkened every semi-transparent texel by up to 59 luma.
+ *
+ * A page image that cannot be read — no 2D context, or a cross-origin image
+ * without CORS, where `getImageData` throws — falls back to the page itself and
+ * caches *that*: the colour is then as wrong as it is today, but it happens
+ * once per image instead of once per frame, and no frame throws. (The cut path
+ * already fails on such an image at `toBlob`, so only the mesh tier can get
+ * here.) An image that has not decoded yet is left uncached, so the derivation
+ * happens once it has.
+ */
+export declare function straightAlphaSource(page: HTMLImageElement, pma: boolean): PageSource;
+/**
+ * How a cut region's PNG is handed to the `<img>`: a `blob:` URL this module
+ * owns and `revokeRegions` frees (the default), or a `data:` URL that owns
+ * nothing and needs no revoke.
+ */
+export type RegionEncoding = 'blob' | 'data';
+export interface UnpackRegionsOptions {
+    /** `'blob'` by default. */
+    encoding?: RegionEncoding;
+}
+/**
+ * Cuts every region of a page layout — a model document's `pages` section —
+ * out of its page image into its own bitmap once at load time, restoring 90°
+ * packing rotation, so the per-frame path never touches a canvas. Returns
+ * image URLs keyed by region name. `pageImages` is keyed by page name.
+ * `loadModel` calls this; it is exported for callers whose page images do not
+ * come from a URL.
+ *
+ * This is a loading-pipeline step, not a rendering step: after this runs,
+ * rendering is pure DOM (one <img> per slot, one CSS matrix write per frame).
+ *
+ * A region that covers its whole page unrotated skips the cut and reuses the
+ * page image URL — see the pass-through in planCut.
+ *
+ * **A page may ship at a resolution its atlas does not declare.** Half-size
+ * texture builds and @2x variants are normal, and no option is needed for
+ * them: a region's bounds are read relative to the declared page size and
+ * scaled onto the image's natural size, which is exactly how spine-core
+ * derives the UVs the mesh tier already samples with. Each bitmap comes out at
+ * the native resolution of the pixels it was cut from, and the `RegionImage`
+ * sizes beside it stay in atlas units, so nothing downstream has to know.
+ *
+ * *Behaviour change (0.5.1 → next).* An atlas whose `size:` line is simply
+ * wrong — bounds written in image pixels under a page declared some other size
+ * — used to be cut "as the coordinates say", because the cut read the image
+ * directly. It is now read the way every other Spine runtime reads it:
+ * relative to the declared size. Such an atlas rendered with a skewed mesh
+ * tier and an intact rigid tier before; now both tiers agree, and the fix is
+ * to correct the `size:` line.
+ *
+ * **The cuts run concurrently.** PNG encoding is asynchronous and the browser
+ * does it off the main thread, so the encodes are started together and awaited
+ * together instead of one `toBlob` per iteration: awaited in series a load
+ * costs the *sum* of every encode, which a throttled document turns into one
+ * full throttle period per region (measured: a single 8×8 `toBlob` took 7.5 s
+ * to call back in a hidden desktop Chromium pane). How many run at once is
+ * bounded by CUT_BACKING_BUDGET_PX above, not by an option.
+ *
+ * Concurrency changes nothing a caller can observe:
+ *
+ * - **Order.** The returned map is keyed in layout order — pages in order,
+ *   each page's regions in order, which is the atlas's own order — whatever
+ *   order the blobs arrive in: the map is built after the cuts settle, from
+ *   the region list, not from the arrivals.
+ * - **Duplicate names.** The last region of a given name in atlas order wins,
+ *   and the shadowed URL is revoked (and dropped from the ledger) rather than
+ *   stranded.
+ * - **Failure.** Every URL this call minted is revoked before the error
+ *   propagates, *including cuts that were still in flight when the first
+ *   failure happened* — their blobs arrive later, and a load that walked away
+ *   from them would mint owned URLs nobody could ever revoke. So a failure
+ *   stops new cuts from starting but still waits for the started ones, and the
+ *   error it raises is the one from the earliest region in atlas order (what
+ *   the serial loop used to throw). Nothing here rejects unobserved.
+ *
+ * The blob URLs stay alive until revokeRegions() frees them — a document-wide
+ * allocation the GC cannot reclaim on its own. Callers that load and unload
+ * skeletons repeatedly (cutscenes, level transitions) must pair every
+ * unpackRegions() with a revokeRegions(); a caller that loads once for the
+ * page lifetime can ignore it.
+ */
+export declare function unpackRegions(pages: readonly PageLayout[], pageImages: ReadonlyMap<string, HTMLImageElement>, options?: UnpackRegionsOptions): Promise<Map<string, RegionImage>>;
+/**
+ * Frees the blob URLs unpackRegions minted for `images` — the counterpart of
+ * unpackRegions, to call once the skeletons using them are gone (after
+ * `renderer.dispose()`, since a live <img> would keep pointing at a dead URL).
+ *
+ * Only URLs this module created are revoked: entries the caller supplied
+ * itself (a hand-built map of loose part PNGs) and page images reused
+ * verbatim by the whole-page pass-through are left alone. Idempotent —
+ * revoking twice is a no-op, so it is safe on a map that is shared or
+ * partially reused.
+ *
+ * The map keeps its entries; drop the reference (or reload) afterwards, since
+ * the URLs no longer resolve.
+ */
+export declare function revokeRegions(images: Map<string, RegionImage>): void;
+//# sourceMappingURL=DomTexture.d.ts.map

package/dist/DomTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomTexture.d.ts","sourceRoot":"","sources":["../src/DomTexture.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CAChC;AAQD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB;AAkBD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAqC9D;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,OAAO,GAAG,UAAU,CAcpF;AAuSD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,oBAAoB;IACnC,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CA4EnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI,CAEpE"}

package/dist/MeshGlBlitter.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Shared offscreen WebGL rasterizer for the mesh (deform) tier.
+ *
+ * One module-level context serves every renderer instance: browsers cap live
+ * WebGL contexts (16 on Chrome/Safari) and a page can hold many renderers, so
+ * per-renderer contexts would evict each other. Per flush, every dirty mesh is
+ * shelf-packed into a rect of the offscreen canvas, its triangles are drawn
+ * textured (atlas page texture, premultiplied alpha), and each rect is blitted
+ * onto the mesh's per-part 2d canvas with an unclipped drawImage rect copy.
+ * The texture is premultiplied either by the upload or by the exporter — a
+ * `pma: true` page arrives that way, so it is uploaded unconverted (textureFor).
+ *
+ * Why this exists: Safari antialiases canvas2d clip paths, so the standard
+ * per-triangle clip+transform+drawImage mapping pays a per-triangle AA-mask
+ * cost in the GPU process — invisible to in-callback JS timing, but it
+ * rAF-limits heavy scenes. GL rasterizes shared triangle edges seamlessly
+ * (no clip, no crack overdraw needed), and the remaining canvas2d work is a
+ * plain rect blit.
+ *
+ * The offscreen buffer is scratch space: rects are scissor-cleared and
+ * redrawn every flush and read back in the same task, so neither
+ * preserveDrawingBuffer nor cross-frame content is relied on. The buffer
+ * grows quantized and never shrinks, mirroring the per-part backing policy
+ * (reallocating GPU surfaces per frame is a Safari killer).
+ *
+ * Page textures are the one thing here with a lifetime, and since this object
+ * outlives every renderer they are reference-counted: a renderer retains each
+ * page it queues a job for and releases them in dispose(), and the last
+ * release deletes the GL texture (a later job re-uploads it). The cache is
+ * keyed weakly by the page image, so a consumer that never disposes still
+ * loses nothing but GPU memory — this object never pins the caller's image.
+ *
+ * The canvas render mode (`CanvasRenderer`) draws through the same context: a
+ * `FrameJob` is a whole player's frame — every region and mesh as textured,
+ * vertex-coloured triangles in draw order, with the blend mode as batch state —
+ * into one rect, blitted onto that player's one visible canvas. It has its own
+ * program (colour and optional dark attributes) so the mesh tier's program and
+ * its output stay exactly what they were; both share the page textures and
+ * their reference counts.
+ */
+import type { BlendMode } from './posedFrame.js';
+export interface MeshBlitJob {
+    /** Destination per-part canvas; the blit clears its full backing first. */
+    canvas: HTMLCanvasElement;
+    /** Atlas page image the mesh samples (cached as a GL texture on first use). */
+    page: HTMLImageElement;
+    /**
+     * `page.pma` — whether the page's texels are already premultiplied, which
+     * decides whether the upload premultiplies them again (see textureFor). It
+     * travels with the page because it describes the page's *pixels*, and the
+     * blend below wants them premultiplied exactly once.
+     */
+    pma: boolean;
+    /** Bbox-relative vertices in CSS px, x/y interleaved (indexed via `triangles`). */
+    vertices: Float64Array;
+    /** Normalized page UVs aligned with `vertices`. */
+    uvs: ArrayLike<number>;
+    /** Triangle index list into vertex/UV pairs. */
+    triangles: ArrayLike<number>;
+    /** Backing-store pixels per CSS px. */
+    ratio: number;
+    /** Rasterized region in device px — the packed rect and the blit both use it. */
+    width: number;
+    height: number;
+}
+/**
+ * One run of a frame job's triangles: a stretch of the vertex data that samples
+ * one page under one blend mode — one draw call.
+ */
+export interface FrameRun {
+    page: HTMLImageElement;
+    /** `page.pma`, as for MeshBlitJob. */
+    pma: boolean;
+    blend: BlendMode;
+    /** First vertex of the run (not float) in `FrameJob.data`. */
+    first: number;
+    /** Vertices in the run — three per triangle. */
+    count: number;
+}
+/**
+ * A whole frame of one player (the canvas render mode): unindexed triangles,
+ * interleaved per vertex as
+ * `x, y, u, v, r, g, b, a` (stride 8) or `x, y, u, v, r, g, b, a, dr, dg, db`
+ * (stride 11, the two-colour form, only when the frame carries a dark colour).
+ * Positions are device px relative to the job's rect, top-left origin; the
+ * colour is premultiplied by its alpha and so is the dark colour. Drawn into
+ * one rect of the offscreen buffer, then blitted onto `canvas` in one
+ * `drawImage`.
+ */
+export interface FrameJob {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    data: Float32Array;
+    stride: 8 | 11;
+    runs: FrameRun[];
+}
+declare class MeshGlBlitter {
+    lost: boolean;
+    /**
+     * Page textures created minus deleted, i.e. how many uploads are live right
+     * now. Deterministic (no GC in the path), which is what the lifetime tests
+     * assert against — see tests/gl-textures.spec.ts.
+     */
+    liveTextureCount: number;
+    private readonly canvas;
+    private readonly gl;
+    private readonly uResolution;
+    private readonly meshProgram;
+    private readonly meshPos;
+    private readonly meshUV;
+    private readonly frameProgram;
+    private readonly frameResolution;
+    private readonly frameOrigin;
+    private readonly framePos;
+    private readonly frameUV;
+    private readonly frameColor;
+    private readonly frameDark;
+    /** Which program's attribute layout is bound — each flush binds its own. */
+    private bound;
+    /**
+     * Weak by the page image on purpose: a consumer that forgets dispose()
+     * leaks its texture until context loss, but dropping the image still lets
+     * the image (and then the WebGLTexture this entry holds) be collected.
+     * Reassigned wholesale on context loss, never iterated.
+     */
+    private textures;
+    private readonly maxSize;
+    private vertexData;
+    /** Per-job packed rect origins, filled by flush(). */
+    private packX;
+    private packY;
+    constructor();
+    /**
+     * Rasterize every job into the offscreen buffer, then blit each rect onto
+     * its per-part canvas. Returns false when the context is lost (or the jobs
+     * cannot fit) so the caller can rasterize the batch on the canvas2d path.
+     */
+    flush(jobs: MeshBlitJob[]): boolean;
+    /**
+     * Draws one player's frame (the canvas render mode) into a rect of the
+     * offscreen buffer and blits it onto `job.canvas`, whose full backing is
+     * cleared first. Returns false when the context is lost or the rect cannot
+     * fit, so the caller can draw the frame on its canvas2d fallback instead.
+     */
+    flushFrame(job: FrameJob): boolean;
+    /** The mesh tier's layout, [x, y, u, v], and its premultiplied source-over. */
+    private bindMesh;
+    /** The frame layout: [x, y, u, v, r, g, b, a], and [dr, dg, db] at stride 11. */
+    private bindFrame;
+    private disableAttributes;
+    private link;
+    /**
+     * Declares one more user of `page`. The upload itself stays lazy (the first
+     * flush that binds the page does it) — this only counts, so that the last
+     * release() can free the texture instead of the module holding it forever.
+     * Callers retain once per page and hand the same page back exactly once;
+     * DomRenderer and CanvasRenderer each keep that ledger and settle it in dispose().
+     */
+    retain(page: HTMLImageElement): void;
+    /**
+     * Gives back one retain(). The GL texture goes when the last user of the
+     * page is gone; a later job for the same page simply uploads it again. A
+     * page the cache does not know (a release after a context loss dropped
+     * everything, or a double dispose) is a no-op, so this is safe to call
+     * unconditionally.
+     */
+    release(page: HTMLImageElement): void;
+    /**
+     * Context loss invalidates every texture handle at once. Drop the cache and
+     * the count instead of carrying dead handles (deleting them is pointless —
+     * the GPU side is already gone) and let the next frames re-upload if the
+     * caller keeps drawing; the renderer meanwhile falls back to canvas2d.
+     */
+    private markLost;
+    private compile;
+    /**
+     * The page's GL texture, uploaded on demand.
+     *
+     * `pma` is a property of the page's *pixels*, so one image cannot honestly be
+     * both: two atlases naming the same image with different `pma:` lines are not
+     * a mixed page, one of them is simply wrong about the file. The cache is keyed
+     * by the image, so rather than trusting that, a flag that disagrees with the
+     * live upload re-uploads under the new one — the pathological case stays
+     * correct (at the price of re-uploading while it lasts) instead of silently
+     * drawing one of the two atlases wrong.
+     */
+    private textureFor;
+}
+/**
+ * The module-level blitter, created on first use. Returns null when WebGL is
+ * unavailable or the shared context has been lost — callers then stay on the
+ * canvas2d path.
+ */
+export declare function getMeshGlBlitter(): MeshGlBlitter | null;
+export {};
+//# sourceMappingURL=MeshGlBlitter.d.ts.map

package/dist/MeshGlBlitter.d.ts.map

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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { type CanvasBackend, CanvasRenderer, type CanvasViewport } from './CanvasRenderer.js';
+export { DomRenderer, type MeshBackend } from './DomRenderer.js';
+export { type PageLayout, type PageRegion, type RegionEncoding, type RegionImage, revokeRegions, type UnpackRegionsOptions, unpackRegions } from './DomTexture.js';
+export { type LoadModelOptions, loadModel, type ModelAssets, type ModelDocument, type RegionLoading } from './loadModel.js';
+export { type AdjustableBones, type BoneAdjust, type BoneLocals, type BoneWorld, type PlayOptions, type PoseBounds, type QueueOptions, type RenderMode, type RigComplete, type RigEvent, RigPlayer, type RigPlayerOptions, type SlotFilter, type TrackEntry } from './player.js';
+export type { BlendMode, PosedClip, PosedFrame, PosedMesh, PosedRegion, PosedSlot, } from './posedFrame.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnK,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACjR,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC"}