@shopify/react-native-skia 2.6.2 → 2.6.3-next.2

package/src/skia/types/NativeBuffer/NativeBufferFactory.ts

@@ -40,7 +40,16 @@ export interface NativeBufferFactory {
    */
   MakeFromImage: (image: SkImage) => NativeBuffer;
   /**
-   * Release a native buffer that was created with `MakeFromImage`.
+   * Create a native buffer of the given size filled with a procedural test
+   * pattern (RGB gradient + diagonal stripes), entirely on the CPU. Useful for
+   * examples and tests that need a buffer to feed into
+   * `GPUDevice.importExternalTexture` without a camera/video source. Release it
+   * with `Release`.
+   */
+  MakeTestBuffer: (width: number, height: number) => NativeBuffer;
+  /**
+   * Release a native buffer that was created with `MakeFromImage` or
+   * `MakeTestBuffer`.
    */
   Release: (nativeBuffer: NativeBuffer) => void;
 }

package/src/skia/types/WebGPU.ts

@@ -0,0 +1,186 @@
+import type { NativeBuffer } from "./NativeBuffer";
+
+// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by
+// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are
+// only available on native (SK_GRAPHITE) builds, reachable through
+// `Skia.getDevice()`.
+//
+// The exported interfaces below describe the descriptors and objects those
+// entry points use; the `declare global` block augments the standard WebGPU
+// interfaces so the new methods are typed without casting to `any`.
+
+/**
+ * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
+ * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).
+ *
+ * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a
+ * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller
+ * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep
+ * it alive until the imported texture is destroyed.
+ */
+export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {
+  source: NativeBuffer;
+  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */
+  rotation?: number;
+  /** Mirror horizontally while sampling. */
+  mirrored?: boolean;
+}
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the
+ * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see
+ * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and
+ * lifetime rules).
+ */
+export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
+  handle: NativeBuffer;
+}
+
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType =
+  | "mtl-shared-event"
+  | "sync-fd"
+  | "vk-semaphore-opaque-fd";
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+  /**
+   * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+   * the device.
+   */
+  type: GPUSharedFenceType;
+  /**
+   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+   * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+   */
+  handle: bigint;
+  label?: string;
+}
+
+export interface GPUSharedFenceExportInfo {
+  type: GPUSharedFenceType;
+  /**
+   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+   * once consumed.
+   */
+  handle: bigint;
+}
+
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+  readonly __brand: "GPUSharedFence";
+  label: string;
+  export(): GPUSharedFenceExportInfo;
+}
+
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+  fence: GPUSharedFence;
+  signaledValue: bigint;
+}
+
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+  initialized: boolean;
+  fences: GPUSharedFenceState[];
+}
+
+/**
+ * Shared texture memory imported from a platform native buffer via
+ * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
+ * the memory, then bracket the GPU work that touches it with
+ * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.
+ */
+export interface GPUSharedTextureMemory extends GPUObjectBase {
+  /** Create a texture that aliases the shared memory. */
+  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;
+  /**
+   * Acquire the memory for GPU access. `initialized` marks whether the existing
+   * contents should be preserved (pass `true` for an already-rendered frame).
+   * Optional `fences` are wait fences: Dawn waits for each to reach its
+   * `signaledValue` before writing the surface. Throws if the access could not
+   * be acquired.
+   */
+  beginAccess(
+    texture: GPUTexture,
+    initialized: boolean,
+    fences?: GPUSharedFenceState[]
+  ): void;
+  /**
+   * Release the memory after the GPU work that accessed it has been submitted,
+   * and return the fences Dawn produced for the access. Throws on failure.
+   */
+  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
+}
+
+/**
+ * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
+ * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's
+ * toggle list for valid names.
+ */
+export interface GPUDawnTogglesDescriptor {
+  enabledToggles?: string[];
+  disabledToggles?: string[];
+}
+
+declare global {
+  interface GPUDeviceDescriptor {
+    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */
+    dawnToggles?: GPUDawnTogglesDescriptor;
+  }
+
+  interface GPUExternalTexture {
+    /**
+     * Skia extension: end the imported buffer's shared-memory access window and
+     * release the underlying resources. Call right after the `queue.submit()`
+     * that sampled this texture (never before). Idempotent, and also runs at
+     * garbage collection as a fallback.
+     */
+    destroy(): void;
+  }
+
+  interface GPUDevice {
+    /**
+     * Skia extension: import a NativeBuffer (from
+     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled
+     * with `texture_external` in WGSL. The returned texture owns the
+     * shared-memory access window; call `destroy()` on it after the sampling
+     * `queue.submit()`.
+     */
+    importExternalTexture(
+      descriptor: SkiaGPUExternalTextureDescriptor
+    ): GPUExternalTexture;
+    /**
+     * Skia extension: import a NativeBuffer (from
+     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the
+     * lower-level path that lets you create an aliasing texture and manage the
+     * begin/end access window yourself.
+     */
+    importSharedTextureMemory(
+      descriptor: GPUSharedTextureMemoryDescriptor
+    ): GPUSharedTextureMemory;
+    /**
+     * Skia extension: import a native synchronization primitive (an
+     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+     * matching `shared-fence-*` feature must be enabled on the device.
+     */
+    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
+  }
+}

package/src/skia/types/index.ts

@@ -30,6 +30,7 @@ export * from "./Size";
 export * from "./Paragraph";
 export * from "./Matrix4";
 export * from "./NativeBuffer";
+export * from "./WebGPU";
 export * from "./Recorder";
 export * from "./Video";
 export * from "./Skottie";

package/src/skia/web/JsiSkNativeBufferFactory.ts

@@ -25,6 +25,26 @@ export class JsiSkNativeBufferFactory
     return canvas;
   }
 
+  MakeTestBuffer(width: number, height: number): NativeBuffer {
+    const pixels = new Uint8ClampedArray(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * 4;
+        pixels[i + 0] = Math.floor((x * 255) / Math.max(width - 1, 1));
+        pixels[i + 1] = Math.floor((y * 255) / Math.max(height - 1, 1));
+        pixels[i + 2] = (x + y) & 0x20 ? 220 : 30;
+        pixels[i + 3] = 0xff;
+      }
+    }
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to get 2d context from canvas");
+    }
+    ctx.putImageData(new ImageData(pixels, width, height), 0, 0);
+    return canvas;
+  }
+
   Release(_nativeBuffer: NativeBuffer) {
     // it's a noop on Web
   }

package/src/skia/web/JsiSkPath.ts

@@ -447,7 +447,10 @@ export class JsiSkPath
   }
 
   simplify() {
-    warnDeprecatedPathMethod("simplify", "Use Skia.Path.Simplify(path) instead.");
+    warnDeprecatedPathMethod(
+      "simplify",
+      "Use Skia.Path.Simplify(path) instead."
+    );
     const path = this.asPath();
     const result = path.makeSimplified();
     path.delete();
@@ -500,7 +503,10 @@ export class JsiSkPath
   }
 
   stroke(opts?: StrokeOpts) {
-    warnDeprecatedPathMethod("stroke", "Use Skia.Path.Stroke(path, opts) instead.");
+    warnDeprecatedPathMethod(
+      "stroke",
+      "Use Skia.Path.Stroke(path, opts) instead."
+    );
     const path = this.asPath();
     const result = path.makeStroked(
       opts === undefined

package/scripts/install-libs.js

@@ -1,133 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const path = require("path");
-const fs = require("fs");
-
-const useGraphite =
-  process.env.SK_GRAPHITE === "1" ||
-  (process.env.SK_GRAPHITE || "").toLowerCase() === "true";
-const prefix = useGraphite ? "react-native-skia-graphite" : "react-native-skia";
-const libsDir = path.join(__dirname, "..", "libs");
-
-function copySync(src, dest, options) {
-  if (!src.includes("*")) {
-    return fs.cpSync(src, dest, options);
-  }
-
-  const wildcardSplit = src.split("*");
-  const basePath = wildcardSplit[0];
-  const files = fs.readdirSync(basePath);
-  files
-    .filter((file) => file.endsWith(wildcardSplit[1]))
-    .forEach((file) => {
-      return fs.cpSync(
-        path.join(basePath, file),
-        path.join(dest, file),
-        options
-      );
-    });
-}
-
-// --- Apple platforms ---
-
-let iosPackage, macosPackage;
-try {
-  iosPackage = path.dirname(
-    require.resolve(prefix + "-apple-ios/package.json")
-  );
-  macosPackage = path.dirname(
-    require.resolve(prefix + "-apple-macos/package.json")
-  );
-} catch (e) {
-  console.error(
-    "ERROR: Could not find " +
-      prefix +
-      "-apple-ios or " +
-      prefix +
-      "-apple-macos"
-  );
-  console.error("Make sure you have run yarn install or npm install");
-  process.exit(1);
-}
-
-// Verify xcframeworks exist in the iOS package
-const iosXcf = path.join(iosPackage, "libs");
-if (
-  !fs.existsSync(iosXcf) ||
-  !fs.readdirSync(iosXcf).some((f) => f.endsWith(".xcframework"))
-) {
-  console.error(
-    "ERROR: Skia prebuilt binaries not found in " + prefix + "-apple-ios!"
-  );
-  process.exit(1);
-}
-
-console.log("-- Skia iOS package: " + iosPackage);
-console.log("-- Skia macOS package: " + macosPackage);
-
-// Clean and copy Apple frameworks
-fs.rmSync(path.join(libsDir, "ios"), { recursive: true, force: true });
-fs.rmSync(path.join(libsDir, "macos"), { recursive: true, force: true });
-fs.rmSync(path.join(libsDir, "tvos"), { recursive: true, force: true });
-fs.mkdirSync(path.join(libsDir, "ios"), { recursive: true });
-fs.mkdirSync(path.join(libsDir, "macos"), { recursive: true });
-
-copySync(iosPackage + "/libs/*.xcframework", path.join(libsDir, "ios"), {
-  recursive: true,
-});
-copySync(macosPackage + "/libs/*.xcframework", path.join(libsDir, "macos"), {
-  recursive: true,
-});
-
-// Handle tvOS (non-Graphite only)
-if (!useGraphite) {
-  try {
-    const tvosPackage = path.dirname(
-      require.resolve(prefix + "-apple-tvos/package.json")
-    );
-    console.log("-- Skia tvOS package: " + tvosPackage);
-    fs.mkdirSync(path.join(libsDir, "tvos"), { recursive: true });
-    copySync(tvosPackage + "/libs/*.xcframework", path.join(libsDir, "tvos"), {
-      recursive: true,
-    });
-  } catch (e) {
-    console.log("-- tvOS package not found, skipping");
-  }
-}
-
-console.log("-- Copied Apple xcframeworks to libs/");
-
-// --- Android ---
-
-const androidPackageName = useGraphite
-  ? "react-native-skia-graphite-android"
-  : "react-native-skia-android";
-
-let androidPackage;
-try {
-  androidPackage = path.dirname(
-    require.resolve(androidPackageName + "/package.json")
-  );
-} catch (e) {
-  console.error("ERROR: Could not find " + androidPackageName);
-  console.error("Make sure you have run yarn install or npm install");
-  process.exit(1);
-}
-
-const androidSrcLibs = path.join(androidPackage, "libs");
-if (!fs.existsSync(androidSrcLibs)) {
-  console.error(
-    "ERROR: Skia prebuilt binaries not found in " + androidPackageName + "!"
-  );
-  process.exit(1);
-}
-
-console.log("-- Skia Android package: " + androidPackage);
-
-// Copy Android libs (per-ABI static libraries)
-const androidDest = path.join(libsDir, "android");
-fs.rmSync(androidDest, { recursive: true, force: true });
-copySync(androidSrcLibs, androidDest, { recursive: true });
-
-console.log("-- Copied Android libs to libs/android/");