@rive-app/webgl2-threads 2.48.0 → 2.49.1

package/rive_advanced.mjs.d.ts

@@ -46,6 +46,9 @@ export interface RiveCanvas {
   RenderPaintStyle: typeof RenderPaintStyle;
   StrokeCap: typeof StrokeCap;
   StrokeJoin: typeof StrokeJoin;
+  StrokePosition: typeof StrokePosition;
+  ImageFilter: typeof ImageFilter;
+  ImageWrap: typeof ImageWrap;
   decodeAudio: DecodeAudio;
   decodeImage: DecodeImage;
   decodeFont: DecodeFont;
@@ -73,6 +76,23 @@ export interface RiveCanvas {
    */
   makeDeferredSession?(): DeferredSession | undefined;
 
+  /**
+   * @experimental Lets deferred renderers replay on one worker shared by the
+   * page. Only in the threaded webgl2 build; call it before loading files, so
+   * their images reach the worker too.
+   *
+   * @returns false where the browser cannot draw WebGL2 on a transferred canvas
+   */
+  enableReplayWorker?(): boolean;
+
+  /**
+   * @internal Settles once the replay worker's device caps reach the page, so
+   * scripts read truthful features before any canvas reaches the worker.
+   *
+   * @returns undefined when nothing replays on the worker
+   */
+  awaitReplayCaps?(): Promise<void> | undefined;
+
   /**
    * Loads a Rive file for the runtime and returns a Rive-specific File class
    *
@@ -203,6 +223,18 @@ export interface RendererOptions {
    * converted to clockwise on a best-effort basis
    */
   inkbleed?: boolean;
+  /**
+   * @experimental (webgl2-threads only) Hands the canvas to the replay worker,
+   * once `enableReplayWorker()` has succeeded. The renderer then replays only
+   * deferred sessions. A canvas handed over before keeps going to the worker.
+   */
+  replayWorker?: boolean;
+  /**
+   * @experimental (webgl2-threads only) Called when the replay worker
+   * restores the renderer's lost context, so an idle instance still draws
+   * and notices it.
+   */
+  onContextRestored?: () => void;
 }
 
 /**
@@ -277,6 +309,22 @@ export declare class RendererWrapper {
    * @returns false if inkbleed was requested but the canvas context does not support it
    */
   setInkbleed?(enabled: boolean): boolean;
+  /**
+   * @experimental Present on renderers whose canvas is on the replay worker,
+   * which can only draw deferred sessions.
+   */
+  replaysOnWorker?(): boolean;
+  /**
+   * @experimental False while the replay worker has yet to take the canvas, or
+   * is as many frames behind as it queues. Skip the frame rather than record it.
+   */
+  acceptsFrame?(): boolean;
+  /**
+   * @experimental True once the replay worker's context was lost and restored.
+   * What it held is gone, so the renderer and the file's session must be
+   * recreated.
+   */
+  contextRestored?(): boolean;
 }
 
 export declare class RenderPathWrapper {
@@ -304,11 +352,15 @@ export declare class RenderPathWrapper {
   close(): void;
 }
 
+export declare class RenderImageWrapper {
+}
+
 export declare class RenderPaintWrapper {
   color(value: number): void;
   thickness(value: number): void;
   join(value: StrokeJoin): void;
   cap(value: StrokeCap): void;
+  strokePosition(value: StrokePosition): void;
   blendMode(value: BlendMode): void;
   style(value: RenderPaintStyle): void;
   linearGradient(sx: number, sy: number, ex: number, ey: number): void;
@@ -323,6 +375,19 @@ export declare class RenderPaintWrapper {
     tx: number,
     ty: number,
   ): void;
+
+  modulatedImage(
+    image: RenderImage,
+    filter: ImageFilter,
+    wrapX: ImageWrap,
+    wrapY: ImageWrap,
+    xx: number,
+    xy: number,
+    yx: number,
+    yy: number,
+    tx: number,
+    ty: number,
+  ): void;
 }
 
 /**
@@ -352,6 +417,8 @@ export declare class RenderPath extends RenderPathWrapper { }
 
 export declare class RenderPaint extends RenderPaintWrapper { }
 
+export declare class RenderImage extends RenderImageWrapper { }
+
 /////////////////////
 // CANVAS RENDERER //
 /////////////////////
@@ -1212,7 +1279,7 @@ export declare class StateMachineInstance {
 
   /**
    * The selected text of the focused element, or an empty string when nothing with a
-   * selection is focused. Used to fill the clipboard on copy/cut. An obscured field 
+   * selection is focused. Used to fill the clipboard on copy/cut. An obscured field
    * (i.e. a password) reports empty string.
    */
   selectedText(): string;
@@ -1541,6 +1608,23 @@ export enum BlendMode {
   luminosity = 28,
 }
 
+export enum ImageFilter {
+  bilinear,
+  nearest,
+}
+
+export enum ImageWrap {
+  clamp,
+  repeat,
+  mirror,
+}
+
+export enum StrokePosition {
+  inside,
+  center,
+  outside,
+}
+
 ///////////
 // UTILS //
 ///////////

package/runtimeLoader.d.ts

@@ -10,6 +10,10 @@ export declare class RuntimeLoader {
     private static wasmBinary;
     private static wasmThreadsURL;
     private static triedThreads;
+    private static parallelParts;
+    private static replayWorker;
+    private static replayCapsArrived;
+    private static readonly replayCapsTimeoutMs;
     private static errorCallbackQueue;
     private constructor();
     /**
@@ -23,6 +27,12 @@ export declare class RuntimeLoader {
     private static loadUnthreaded;
     static getInstance(callback: RuntimeCallback, onError?: (error: Error) => void): void;
     static awaitInstance(): Promise<rc.RiveCanvas>;
+    /**
+     * @internal Resolves once the replay worker's device caps reach the page,
+     * so scripts init against them. Null when there is nothing left to wait
+     * for, which keeps every later instance's load synchronous.
+     */
+    static awaitReplayCaps(): Promise<void> | null;
     static setWasmUrl(url: string): void;
     static getWasmUrl(): string;
     /**
@@ -43,6 +53,29 @@ export declare class RuntimeLoader {
      */
     static setWasmThreadsUrl(url: string | null): void;
     static getWasmThreadsUrl(): string | null;
+    /**
+     * Sets how many parts a script's parallel call gets on a page that runs
+     * the threaded build, the page's thread and one worker thread for each
+     * other part. 1 turns parallel calls off, and null leaves the runtime's
+     * default of one part per core, up to 8. Set it before the first file
+     * loads.
+     */
+    static setParallelParts(parts: number | null): void;
+    static getParallelParts(): number | null;
+    private static applyParallelParts;
+    /**
+     * @experimental When the threaded build loads, instances with
+     * `enableGPUCanvas` hand their canvas to one worker that replays every
+     * instance's frames while the page records the next ones. Pass `false`
+     * before the runtime loads to keep replay on the page's thread; a single
+     * instance can opt out with `useReplayWorker: false`. Pages where the
+     * browser cannot draw WebGL2 on a transferred canvas stay on the page's
+     * thread regardless.
+     *
+     * True by default.
+     */
+    static setReplayWorker(enabled: boolean): void;
+    static getReplayWorker(): boolean;
     static setWasmBinary(value: ArrayBuffer | null): void;
     static getWasmBinary(): ArrayBuffer | null;
 }