@airisu-dev/react-native-live2d-skia 0.0.0-stage → 0.1.0

package/src/rendering/ticker/types.ts

@@ -0,0 +1,57 @@
+import type { Synchronizable } from 'react-native-worklets'
+import type { Live2DModel as NativeModel } from '../../specs/react-native-live2d-skia.nitro'
+import type { CanvasInfo } from '../drawer'
+import type { SkImage, SkPicture, SkShader } from '../skia'
+
+/** Averages per frame over the last second, in milliseconds unless noted. */
+export interface Live2DFrameStats {
+  fps: number
+  /** The frame rate the loop aims for: the display's refresh rate, or `maxFps`. */
+  targetFps: number
+  /** All work for this model's frame on the animation thread. */
+  workMs: number
+  /** Motions, physics and so on in C++ (`update`). */
+  updateMs: number
+  /** Copying vertex data out of C++ (`getDrawables`). 0 when drawn in C++. */
+  drawablesMs: number
+  /** Recording the picture, including `meshMs`. */
+  drawMs: number
+  /** Building Skia vertices for drawables that moved. */
+  meshMs: number
+  /** Meshes rebuilt per frame (a count). */
+  meshesBuilt: number
+  /**
+   * Mask layers per frame (a count). Their cost is in the UI thread's Skia
+   * draw, which these stats don't cover.
+   */
+  layers: number
+  /** Models animated by the loop, this one included (a count). */
+  models: number
+  /** All work for a frame of the loop, every model included. */
+  loopWorkMs: number
+}
+
+/** A newly drawn frame, for the UI thread to pick up. */
+export type PublishedFrame = { frame: number; picture: SkPicture } | null
+
+export interface TickerView {
+  target: Synchronizable<PublishedFrame>
+  /** The frame the UI thread shows (-1 before the first). Frames are freed once every view is past them. */
+  shown: Synchronizable<number>
+  /** Set to false to stop showing frames here. */
+  running: Synchronizable<boolean>
+  /** The display's frame interval, measured on the UI thread; 0 until known. */
+  displayMs: Synchronizable<number>
+  /** Shortest frame time for this view (`maxFps`); 0 for no cap. */
+  capMs: number
+  /** Gets frame stats about once a second; null if not wanted. */
+  report: ((stats: Live2DFrameStats) => void) | null
+}
+
+export interface TickerModel {
+  id: number
+  native: NativeModel
+  textures: SkImage[]
+  shaders: SkShader[]
+  canvas: CanvasInfo
+}

package/src/specs/react-native-live2d-skia.nitro.ts

@@ -0,0 +1,88 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+
+export interface DrawableData {
+  /** Index into the model's drawables; `masks` refers to these. */
+  index: number
+  /** Cubism's visibility flag. Hidden drawables can still be used as masks. */
+  visible: boolean
+  textureIndex: number
+  opacity: number
+  /** Cubism constant flags (`csmBlendAdditive`, `csmIsInvertedMask`, ...). */
+  constantFlags: number
+  /** Indices of the drawables that clip this one. Empty if unmasked. */
+  masks: number[]
+  /** float32 x/y pairs in model units, y-up. */
+  positions: ArrayBuffer
+  /** float32 u/v pairs in 0..1, v-up. */
+  uvs: ArrayBuffer
+  /** uint16 triangle indices. */
+  indices: ArrayBuffer
+}
+
+/** Like the Cubism SDK samples: a higher priority interrupts a lower one. */
+export type MotionPriority = 'idle' | 'normal' | 'force'
+
+/**
+ * Thread-safe: the model can be updated on one thread while another starts
+ * motions or moves the focus.
+ */
+export interface Live2DModel extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  readonly canvasWidth: number
+  readonly canvasHeight: number
+  readonly originX: number
+  readonly originY: number
+  readonly pixelsPerUnit: number
+  readonly drawableCount: number
+  /** All drawables sorted by render order (back to front), including hidden ones. */
+  getDrawables(): DrawableData[]
+  loadPhysics(json: string): void
+  loadPose(json: string): void
+  /**
+   * Loads one `motion3.json` as entry `index` of motion `group`.
+   * Fade times come from `model3.json` when it defines them.
+   */
+  loadMotion(group: string, index: number, json: string): void
+  /**
+   * Starts a loaded motion, or a random one of `group` without `index`.
+   * Returns false if it isn't loaded or a higher priority motion is playing.
+   */
+  startMotion(group: string, index?: number, priority?: MotionPriority): boolean
+  loadExpression(name: string, json: string): void
+  /**
+   * Fades to a loaded expression, or a random one without `name`.
+   * Returns false if it isn't loaded.
+   */
+  setExpression(name?: string): boolean
+  clearExpression(): void
+  /**
+   * Holds a parameter at `value` until `clearParameter`. Applied after motions,
+   * expressions, eye blink, look and breath, before physics and pose.
+   */
+  setParameter(id: string, value: number): void
+  clearParameter(id: string): void
+  /**
+   * Makes the model look at a point, easing towards it: -1..1 on each axis,
+   * y-up, (0, 0) is straight ahead.
+   */
+  focus(x: number, y: number): void
+  /**
+   * Names of the `model3.json` hit areas containing a point in model units
+   * (y-up, see `originX`/`pixelsPerUnit`), in the order they're listed.
+   */
+  hitTest(x: number, y: number): string[]
+  /**
+   * Advances the model by `deltaSeconds`: motions (a random `Idle` motion
+   * whenever nothing plays), expression, eye blink, look, breath, held
+   * parameters, physics and pose.
+   * Pass 0 to just apply the current state.
+   */
+  update(deltaSeconds: number): void
+}
+
+export interface Live2dSkia extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  /**
+   * Loads a `.moc3` file with its `model3.json` (used for eye blink and lip
+   * sync parameters and motion fade times). Throws if the moc is invalid.
+   */
+  loadModel(moc: ArrayBuffer, settingsJson: string): Live2DModel
+}

package/src/utils/clock.ts

@@ -0,0 +1,10 @@
+// performance.now() exists on the JS thread and on worklet runtimes, but this
+// package's TypeScript lib (esnext, no DOM) doesn't declare it.
+type WithPerformance = { performance: { now(): number } }
+
+export function now(): number {
+  'worklet'
+  // Read globalThis here, not from a module constant: a worklet copies what it
+  // captures to its runtime, and the global object can't be copied (it's cyclic).
+  return (globalThis as unknown as WithPerformance).performance.now()
+}