@rive-app/webgl2-threads 2.47.1 → 2.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rive-app/webgl2-threads",
-  "version": "2.47.1",
+  "version": "2.49.0",
   "description": "Rive's webgl2 based web api, with threads on cross origin isolated pages.",
   "main": "rive.js",
   "homepage": "https://rive.app",

package/rive.d.ts

@@ -58,6 +58,17 @@ export interface RiveFocusOptions {
      */
     allowFocusInterrupt: boolean;
 }
+export interface RiveGamepadOptions {
+    /**
+     * When true, button and stick input only reaches the graphic while DOM focus is
+     * on the canvas (or its accessibility overlay). While focus is elsewhere,
+     * controllers still report as connected, but their input is held at rest.
+     * Useful when several gamepad-driven graphics share a page.
+     *
+     * @default false
+     */
+    requireFocus?: boolean;
+}
 export interface LayoutParameters {
     fit?: Fit;
     alignment?: Alignment;
@@ -350,6 +361,10 @@ export interface RiveParameters {
      * Optional settings for focus behavior
      */
     focusOptions?: RiveFocusOptions;
+    /**
+     * Optional settings for gamepad input
+     */
+    gamepadOptions?: RiveGamepadOptions;
     /**
      * Allow the runtime to automatically load assets hosted in Rive's CDN.
      * enabled by default.
@@ -374,6 +389,11 @@ export interface RiveParameters {
      * will be attached to the <canvas> element
      */
     shouldDisableRiveListeners?: boolean;
+    /**
+     * Turn off sending gamepad input to Rive. Connected game controllers are not read and the
+     * state machine receives no gamepad events.
+     */
+    shouldDisableGamepad?: boolean;
     /**
      * For Rive Listeners, allows scrolling behavior to still occur on canvas elements
      * when a touch/drag action is performed on touch-enabled devices. Otherwise,
@@ -423,6 +443,19 @@ export interface RiveParameters {
      * import. False by default.
      */
     enableGPUCanvas?: boolean;
+    /**
+     * @experimental This API is early and may encounter breaking behavior change without a major version bump
+     *
+     * With `enableGPUCanvas`, on `@rive-app/webgl2-threads` loaded threaded, the
+     * canvas moves to a worker shared by every instance on the page, which replays
+     * each frame while this instance records the next. Set false to keep this
+     * instance's rendering on the page's thread. Has no effect where the worker is
+     * unavailable. True by default; see also {@link RuntimeLoader.setReplayWorker}.
+     *
+     * A canvas handed to the worker stays there: its `width` and `height` still
+     * work, but it can no longer give out a context of its own.
+     */
+    useReplayWorker?: boolean;
     /**
      * Emit performance.mark / performance.measure entries for load lifecycle
      * events and the first 3 render frames. Useful for profiling Rive's
@@ -688,14 +721,17 @@ export declare class Rive {
     private readyForPlaying;
     private runtime;
     private deferredRenderer;
+    private useReplayWorker;
     private _inkbleedCapable;
     private _inkbleed;
     private static inkbleedUnsupportedWarned;
+    private static replayContextLostWarned;
     private static inkbleedNotCapableWarned;
     private ownsRiveFile;
     private artboard;
     private eventCleanup;
     private _keyboardInteractions;
+    private _gamepadInteractions;
     private file;
     private riveFile;
     private eventManager;
@@ -718,6 +754,8 @@ export declare class Rive {
     static get suppressDeprecationWarnings(): readonly DeprecationId[];
     static set suppressDeprecationWarnings(ids: readonly DeprecationId[]);
     private shouldDisableRiveListeners;
+    private shouldDisableGamepad;
+    private _gamepadOptions;
     private automaticallyHandleEvents;
     private dispatchPointerExit;
     private enableMultiTouch;
@@ -803,6 +841,9 @@ export declare class Rive {
     private wantsTextInputSession;
     private advanceAndDrainForPointer;
     private cleanupKeyboardInteractions;
+    private ensureGamepadInteractions;
+    private cleanupGamepadInteractions;
+    private isFocusWithinCanvas;
     /**
      * Remove Rive Listeners setup on the canvas
      */
@@ -822,6 +863,13 @@ export declare class Rive {
      * only a file this instance imported is released when that happens.
      */
     private resolveDeferredRendering;
+    private reloadForRestoredContext;
+    /**
+     * Re-imports `file` deferred and attaches the copy's session to `renderer`.
+     * The copy becomes this instance's file either way, unless the instance was
+     * destroyed while it imported.
+     */
+    private attachDeferredCopy;
     private initArtboard;
     drawFrame(): void;
     private _canvasSizeChanged;
@@ -833,6 +881,7 @@ export declare class Rive {
     /** Mirror Rive's hasFocus into the keyboard session state and, on opt-in, canvas focus. */
     private syncRiveFocus;
     private lastRenderTime;
+    private static batchStart;
     private frameRequestId;
     /**
      * Used be draw to track when a second of active rendering time has passed.
@@ -844,11 +893,12 @@ export declare class Rive {
      * due to state changes, view model property changes, etc.
      *
      * @param elapsedTime time to advance the state machine by
+     * @param frameTime the rAF timestamp; omitted by pointer drains, which skip gamepad polling.
      */
     private advanceAndReportChanges;
     /**
      * Draw rendering loop; renders animation frames at the correct time interval.
-     * @param time the time at which to render a frame
+     * @param time the rAF timestamp, or null to draw now without advancing
      */
     private draw;
     /**