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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 airisu.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Live2dSkia.podspec

@@ -0,0 +1,159 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# Cubism SDK for Native: proprietary, so each app downloads it from Live2D and
+# sets its folder (app.plugin.js writes live2dSkia.cubismSdkPath to
+# Podfile.properties.json, relative to ios/).
+ios_dir = Pod::Config.instance.installation_root.to_s
+podfile_properties_path = File.join(ios_dir, "Podfile.properties.json")
+podfile_properties = File.exist?(podfile_properties_path) ? JSON.parse(File.read(podfile_properties_path)) : {}
+configured_sdk_dir = ENV["LIVE2D_SKIA_CUBISM_SDK"] || podfile_properties["live2dSkia.cubismSdkPath"]
+unless configured_sdk_dir
+  raise "[react-native-live2d-skia] Cubism SDK for Native isn't configured. Add the plugin to app.json: " \
+        "[\"@airisu-dev/react-native-live2d-skia\", { \"cubismSdkPath\": \"./vendor/CubismSdkForNative\" }], download the SDK with " \
+        "`@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm), then prebuild."
+end
+cubism_sdk_dir = File.expand_path(configured_sdk_dir, ios_dir)
+cubism_info = File.join(cubism_sdk_dir, "cubism-info.yml")
+unless File.file?(cubism_info)
+  raise "[react-native-live2d-skia] Cubism SDK for Native not found at #{cubism_sdk_dir} (no cubism-info.yml). " \
+        "Download it with `@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm)."
+end
+cubism_version = File.read(cubism_info)[/^version:\s*(\S+)/, 1] || "unknown"
+
+# A Cubism SDK version as a number: major * 10000 + release * 100 + patch, so
+# 5-r.4.1 is 50401 (a -beta suffix is ignored). Nil if it isn't one.
+cubism_version_number = lambda do |version|
+  m = version.match(/^(\d+)-r\.(\d+)(?:\.(\d+))?/)
+  m && m[1].to_i * 10000 + m[2].to_i * 100 + m[3].to_i
+end
+
+# Listed versions (cubismSdk.versions in package.json) are supported. A newer
+# release of a listed major only warns; anything else fails.
+listed_versions = package["cubismSdk"]["versions"].keys
+cubism_version_num = cubism_version_number.call(cubism_version)
+unless listed_versions.include?(cubism_version)
+  newest_of_major = cubism_version_num && listed_versions.map { |v| cubism_version_number.call(v) }
+                                                         .select { |n| n / 10000 == cubism_version_num / 10000 }.max
+  if newest_of_major.nil? || cubism_version_num < newest_of_major
+    raise "[react-native-live2d-skia] Cubism SDK for Native #{cubism_version} at #{cubism_sdk_dir} isn't supported: use #{listed_versions.join(', ')}."
+  end
+  Pod::UI.warn "[react-native-live2d-skia] Cubism SDK for Native #{cubism_version} found, tested with #{listed_versions.join(', ')}."
+end
+
+# CocoaPods only compiles files inside the pod, and the SDK ships one Core static
+# library per slice. So copy the Framework source in, and package the Core
+# slices as an xcframework (CocoaPods then links the right one for device or
+# simulator). Redone when the SDK's folder or version changes. Gitignored, not published.
+cubism_stage_dir = File.join(__dir__, "cubism-sdk")
+cubism_stamp = "#{cubism_sdk_dir}\n#{cubism_version}\n"
+cubism_stamp_path = File.join(cubism_stage_dir, ".stamp")
+unless File.exist?(cubism_stamp_path) && File.read(cubism_stamp_path) == cubism_stamp
+  require "fileutils"
+  require "tmpdir"
+  FileUtils.rm_rf(cubism_stage_dir)
+  FileUtils.mkdir_p(cubism_stage_dir)
+  FileUtils.cp_r(File.join(cubism_sdk_dir, "Framework", "src"), File.join(cubism_stage_dir, "Framework"))
+  core = File.join(cubism_sdk_dir, "Core")
+  FileUtils.mkdir_p(File.join(cubism_stage_dir, "Core"))
+  FileUtils.cp_r(File.join(core, "include"), File.join(cubism_stage_dir, "Core", "include"))
+  lib = File.join(core, "lib", "ios")
+  Dir.mktmpdir do |tmp|
+    simulator_lib = File.join(tmp, "libLive2DCubismCore.a")
+    run = lambda do |*cmd|
+      system(*cmd) or raise "[react-native-live2d-skia] Failed to package Cubism Core: #{cmd.join(' ')}"
+    end
+    run.call("lipo", "-create",
+             File.join(lib, "Release-iphonesimulator-arm64", "libLive2DCubismCore.a"),
+             File.join(lib, "Release-iphonesimulator-x86_64", "libLive2DCubismCore.a"),
+             "-output", simulator_lib)
+    run.call("xcodebuild", "-create-xcframework",
+             "-library", File.join(lib, "Release-iphoneos", "libLive2DCubismCore.a"),
+             "-headers", File.join(core, "include"),
+             "-library", simulator_lib, "-headers", File.join(core, "include"),
+             "-output", File.join(cubism_stage_dir, "Live2DCubismCore.xcframework"))
+  end
+  File.write(cubism_stamp_path, cubism_stamp)
+  Pod::UI.puts "[react-native-live2d-skia] Using Cubism SDK for Native #{cubism_version} from #{cubism_sdk_dir}"
+end
+
+# Draw in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp). Skia is linked statically
+# into the app by its pod (named react-native-skia in v3 and v2), so this only
+# needs its headers and the defines it's built with. Which Skia: the one
+# app.plugin.js found in the app's package.json (live2dSkia.skiaPackage), v3
+# (Graphite) or v2 (Ganesh), resolved from the app since a monorepo can have
+# both installed. Without it, models are drawn in JS.
+rn_skia_package = podfile_properties["live2dSkia.skiaPackage"].to_s
+rn_skia_dir = nil
+unless rn_skia_package.empty?
+  app_dir = File.dirname(ios_dir)
+  resolved = IO.popen(["node", "-p",
+                       "require('path').dirname(require.resolve(process.argv[1] + '/package.json', { paths: [process.argv[2]] }))",
+                       rn_skia_package, app_dir], err: File::NULL, &:read).to_s.strip
+  rn_skia_dir = resolved if $?.success? && File.file?(File.join(resolved, "cpp", "api", "JsiSkCanvas.h"))
+end
+rn_skia_graphite = rn_skia_package == "react-native-skia"
+
+Pod::Spec.new do |s|
+  s.name         = "Live2dSkia"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/airisu-dev/react-native-live2d-skia.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+    # Cubism Native Framework (motions, physics, pose, ...)
+    "cubism-sdk/Framework/**/*.{hpp,cpp}",
+  ]
+  # Its Rendering/<backend> folders are left out: we draw with Skia
+  # (see cpp/cubism/CubismRendererStub.cpp).
+  s.exclude_files = "cubism-sdk/Framework/Rendering/*/**/*"
+
+  s.vendored_frameworks = "cubism-sdk/Live2DCubismCore.xcframework"
+  # Set before add_nitrogen_files, which merges its own settings into this.
+  header_search_paths = [
+    "\"$(PODS_TARGET_SRCROOT)/cubism-sdk/Core/include\"",
+    "\"$(PODS_TARGET_SRCROOT)/cubism-sdk/Framework\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/hybrid\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/cubism\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/drawing\"",
+  ]
+  # The SDK's version, for cpp/cubism/CubismCompat.hpp.
+  preprocessor_definitions = ["$(inherited)", "LIVE2D_SKIA_CUBISM_SDK=#{cubism_version_num}"]
+  if rn_skia_dir
+    Pod::UI.puts "[Live2dSkia] Drawing with Skia in C++ (#{rn_skia_dir}, #{rn_skia_graphite ? 'Graphite' : 'Ganesh'})"
+    s.dependency "react-native-skia"
+    skia_headers = ["cpp", "cpp/skia", "cpp/api", "cpp/jsi", "cpp/rnskia", "cpp/rnskia/values", "cpp/utils"]
+    skia_headers << "cpp/dawn/include" if rn_skia_graphite
+    header_search_paths += skia_headers.map { |dir| "\"#{File.join(rn_skia_dir, dir)}\"" }
+    # Same as the Skia pod: struct layouts must match.
+    preprocessor_definitions += ["LIVE2D_SKIA=1",
+                                 "SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API=1",
+                                 "SK_DISABLE_LEGACY_SHAPER_FACTORY=1"]
+    preprocessor_definitions += rn_skia_graphite ? ["SK_GRAPHITE=1"] : ["SK_METAL=1", "SK_GANESH=1"]
+  else
+    Pod::UI.puts "[Live2dSkia] No Skia to draw with in C++, drawing in JS"
+  end
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(" "),
+    "GCC_PREPROCESSOR_DEFINITIONS" => preprocessor_definitions.join(" "),
+  }
+
+  load 'nitrogen/generated/ios/Live2dSkia+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -1,3 +1,259 @@
-# Temporary Holding Version
+# react-native-live2d-skia
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Live2D Cubism models rendered natively in React Native with Skia. No WebView, a hooks API in the style of `pixi-live2d-display`, and one shared C++ codebase for iOS and Android.
+
+[![Version](https://img.shields.io/npm/v/@airisu-dev/react-native-live2d-skia.svg)](https://www.npmjs.com/package/@airisu-dev/react-native-live2d-skia)
+[![Downloads](https://img.shields.io/npm/dm/@airisu-dev/react-native-live2d-skia.svg)](https://www.npmjs.com/package/@airisu-dev/react-native-live2d-skia)
+[![License](https://img.shields.io/npm/l/@airisu-dev/react-native-live2d-skia.svg)](https://github.com/airisu-dev/react-native-live2d-skia/blob/main/LICENSE)
+
+Cubism Core and the Cubism Native Framework only run the model (motions, physics, expressions). Each drawable is drawn with Skia's `drawVertices`, so Skia picks the GPU backend: Metal on iOS, Vulkan or OpenGL on Android.
+
+## Requirements
+
+- Expo with development builds (`expo prebuild`). The React Native CLI isn't supported.
+- React Native 0.78 or higher (Nitro Views), Node 18 or higher.
+- Skia, either version:
+
+| Skia | Package                              | Renderer                 |
+| ---- | ------------------------------------ | ------------------------ |
+| v3   | `react-native-skia` (3.3+)           | Graphite (Vulkan, Metal) |
+| v2   | `@shopify/react-native-skia` (2.10+) | Ganesh (OpenGL, Metal)   |
+
+## Installation
+
+### 1. Install the packages
+
+```bash
+npx expo install @airisu-dev/react-native-live2d-skia react-native-nitro-modules react-native-skia react-native-reanimated react-native-worklets react-native-gesture-handler expo-asset expo-file-system
+```
+
+Install one Skia package, not both. For v2, install `@shopify/react-native-skia` instead of `react-native-skia`, at 2.10 or later: `expo install` can pick an older version (2.6.2 for SDK 57), which hands Skia objects to C++ differently. Pin a newer one, e.g. `npx expo install @shopify/react-native-skia@2.14.0`. The config plugin reads which one the app depends on.
+
+The app needs a `GestureHandlerRootView` at its root.
+
+### 2. Configure Metro
+
+Models are bundled as assets. Add `moc3` to Metro's `assetExts` in `metro.config.js` (create it with `npx expo customize metro.config.js` if the app has none):
+
+```js
+const { getDefaultConfig } = require('expo/metro-config')
+
+const config = getDefaultConfig(__dirname)
+
+// Bundle Live2D model data as assets.
+config.resolver.assetExts.push('moc3')
+
+module.exports = config
+```
+
+The model's JSON files (`model3.json`, motions, physics, expressions) and textures bundle with Expo's defaults. Models loaded from a URL don't need this.
+
+### 3. Get the Cubism SDK for Native
+
+The package doesn't include Live2D's Cubism SDK: its Core is proprietary, and each app downloads it from Live2D, accepting
+[Live2D's license terms](https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html).
+1. Download it (it's checked against a SHA-256):
+
+   ```bash
+   npx @airisu-dev/react-native-live2d-skia fetch-sdk --accept-license   # or bunx, yarn, pnpm
+   ```
+
+   It extracts to `./vendor/CubismSdkForNative` (change it with `--out`). Add `/vendor/` to `.gitignore`, so it's never in a public repo. On EAS Build, run the same command in an `eas-build-post-install` script.
+
+2. Point the config plugin at it, in `app.json`:
+
+   ```json
+   "plugins": [["@airisu-dev/react-native-live2d-skia", { "cubismSdkPath": "./vendor/CubismSdkForNative" }]]
+   ```
+
+3. Run `npx expo prebuild`, then build. A missing or unsupported SDK stops the build with the path it looked at.
+
+Publishing an app built on the SDK may also need Live2D's
+[Cubism SDK Release License](https://www.live2d.com/en/sdk/license/) (businesses above 10M JPY a year).
+
+## Usage
+
+```tsx
+import { Canvas } from '@shopify/react-native-skia' // or 'react-native-skia'
+import { GestureDetector } from 'react-native-gesture-handler'
+import { Live2D, useLive2DGesture, useLive2DModel } from '@airisu-dev/react-native-live2d-skia'
+
+export function Mao() {
+  // A require.context of the model's folder: the files its model3.json lists are loaded from it.
+  const { model, error, loading, retry } = useLive2DModel(
+    require.context('./Mao', true, /\.(json|moc3|png)$/),
+  )
+  const gesture = useLive2DGesture(model, { x: 0, y: 0, scale: 0.4 })
+
+  return (
+    <GestureDetector gesture={gesture}>
+      <Canvas style={{ flex: 1 }}>
+        <Live2D model={model} x={0} y={0} scale={0.4} />
+      </Canvas>
+    </GestureDetector>
+  )
+}
+```
+
+`useLive2DModel` loads once on mount and doesn't throw. The source is read once, so remount the component (e.g. change its `key`) to switch models. The canvas is an ordinary view: size it with styles. Models are drawn at the `x`, `y` and `scale` they're given and clipped to the canvas, so fit them to the measured size.
+
+A tap runs the model's reaction (a `Tap<area>` motion, or an expression for `Head`), and a drag makes it look at the finger.
+
+### Loading from a URL
+
+```tsx
+const { model, error, retry } = useLive2DModel(
+  'https://example.com/haru/haru_greeter_t03.model3.json',
+)
+```
+
+A string is the URL of a `model3.json`. The files it lists are resolved relative to it, and spaces in file names are escaped.
+- Every file (JSON, moc, textures) is fetched in parallel with `expo/fetch`. The only caching is the platform's HTTP cache, so a persistent offline copy is up to the app.
+- Motion sounds are ignored.
+- A failed fetch ends up in `error` as `Live2D: failed to fetch <url> (<status>)`, and network errors (e.g. offline) come through the same way. `retry()` tries again. URLs in error messages never include their query, so tokens don't leak into the UI or logs.
+- Cubism 2 models (`model.json`, `.moc`) can't be loaded: Cubism Core 5 only reads `.moc3`.
+
+#### Protected models
+
+```tsx
+// 1. A token in the query: reused for every file on the same host.
+useLive2DModel('https://cdn.example.com/haru/haru.model3.json?token=abc')
+
+// 2. Headers: sent with every request.
+useLive2DModel(url, { headers: { Authorization: `Bearer ${token}` } })
+
+// 3. A signature per file (e.g. S3 presigned URLs): sign each one yourself.
+useLive2DModel(signedModel3Url, {
+  resolveUrl: (url, file) => api.sign(url), // may return a promise
+})
+```
+
+Options are read once, like the source, and `retry()` reuses them. To load with a fresh token, remount. `resolveUrl` runs on every load, so it can fetch fresh signatures.
+
+### Loading from files
+
+Pass the files yourself as a `Live2DModelSource`:
+
+```tsx
+useLive2DModel({
+  settings: require('./Mao/Mao.model3.json'),
+  moc: require('./Mao/Mao.moc3'),
+  textures: [require('./Mao/Mao.2048/texture_00.png')],
+  physics: require('./Mao/Mao.physics3.json'),
+  motions: { Idle: [require('./Mao/motions/idle.motion3.json')] },
+})
+```
+
+### Several models in one canvas
+
+```tsx
+const gesture = useLive2DGestures([
+  { model: hiyori, ...hiyoriPlace, onMove: (x, y) => moveHiyori(x, y) },
+  { model: mao, ...maoPlace, onMove: (x, y) => moveMao(x, y) },
+])
+
+<GestureDetector gesture={gesture}>
+  <Canvas style={{ flex: 1 }}>
+    <Rect … />                              {/* behind the models */}
+    <Live2D model={hiyori} {...hiyoriPlace} />
+    <Live2D model={mao} {...maoPlace} />
+    <RoundedRect … />                       {/* over the models */}
+  </Canvas>
+</GestureDetector>
+```
+
+Inside a `<Canvas>`, JSX order is drawing order: a `<Live2D>` is one layer among ordinary Skia shapes. One animation loop updates and draws every shown model each frame, and two `<Live2D>`s showing the same model share its frames.
+
+### Controlling the model
+
+Points are in model pixels: the model's canvas at its native size (`model.width` x `model.height`), origin top-left.
+
+```ts
+model.motion('TapBody') // random motion of a group
+model.motion('TapBody', 0, 'force') // given motion and priority (idle / normal / force)
+model.expression('exp_01') // expression; random without a name
+model.resetExpression()
+model.setParameter('ParamAngleX', 30) // held over motions until resetParameter
+model.resetParameter('ParamAngleX')
+model.focus(x, y) // look at a point, easing
+model.resetFocus()
+model.hitTest(x, y) // → ['Head']
+```
+
+Methods can be called from the JS thread while the model animates on its background thread: the native model is locked.
+
+## API
+
+### `useLive2DModel(source, options?)`
+
+`source` is a `require.context` of the model's folder, a `Live2DModelSource`, or the URL of a `model3.json`. It returns:
+
+| Field     | Description                                                      |
+| --------- | ---------------------------------------------------------------- |
+| `model`   | The loaded model, `null` while loading or after an error         |
+| `error`   | Why the last load failed (e.g. a network error for a URL source) |
+| `loading` | `true` while a load is in progress                               |
+| `retry()` | Loads again                                                      |
+
+| Option       | Description                                                                                                                                                                                                                                        |
+| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `headers`    | Sent with every request for a remote file                                                                                                                                                                                                          |
+| `resolveUrl` | `(url, file) => string \| Promise<string>`: the URL to request for each file the `model3.json` lists. `url` is resolved next to it without a query, `file` is the path as listed. Replaces the default, which reuses the `model3.json` URL's query |
+
+### `<Live2D />`
+
+| Prop                  | Description                                                                                                                                                                          |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `model`               | `model` from `useLive2DModel` (renders nothing while `null`)                                                                                                                         |
+| `x`, `y`              | Top-left position on the canvas. Default `0`                                                                                                                                         |
+| `scale`               | Uniform scale of the model's native canvas size. Default `1`                                                                                                                         |
+| `paused`              | Stops animating, keeps the current frame. Default `false`                                                                                                                            |
+| `maxFps`              | Caps the frame rate (e.g. `30` to save battery). Default: the display's refresh rate                                                                                                 |
+| `onFrameStats(stats)` | About once a second: `fps`, `targetFps`, per-frame times (`workMs`, `updateMs`, `drawablesMs`, `drawMs`, `meshMs`), `meshesBuilt`, `layers` (mask layers), `models` and `loopWorkMs` |
+
+### `useLive2DGestures(targets, options?)`
+
+Returns one gesture for a `<GestureDetector>` around the `<Canvas>`. Gestures need a native view, so this can't be a prop of `<Live2D>`, which is drawn inside the canvas. List targets in drawing order.
+- A drag makes every model look at the finger.
+- A tap goes to the topmost model with a hit area under it.
+- A long press (350 ms) on a model's hit area picks it up, if it has `onMove`.
+
+| Target field      | Description                                                                                                                                                                                                    |
+| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `model`           | `model` from `useLive2DModel`                                                                                                                                                                                  |
+| `x`, `y`, `scale` | Same as its `<Live2D>` props, to map touches to the model                                                                                                                                                      |
+| `onHit(hitAreas)` | Called on a tap on its hit areas. Return `true` to skip the default: a random `Tap<Area>` motion (e.g. `TapBody`), else a random expression for `Head`, else a random `Tap` motion (models with one tap group) |
+| `onMove(x, y)`    | Makes it draggable. Called with its new top-left position as the finger moves, keeping the point where it was grabbed; the app moves it                                                                        |
+
+| Option  | Description                                              |
+| ------- | -------------------------------------------------------- |
+| `focus` | Models follow the finger while it's down. Default `true` |
+
+The gesture is built once; targets are read at touch time, so they can change on every render.
+
+### `useLive2DGesture(model, options?)`
+
+The same for one model: `options` is a target (without `model`) plus `focus`.
+
+### `Live2DModel`
+
+| Member                                           | Description                                                                                                                   |
+| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| `motion(group, index?, priority?)`               | Plays a motion; `priority` is `'idle'`, `'normal'` or `'force'`. `false` if there is none or a higher priority one is playing |
+| `expression(name?)`                              | Fades to an expression, random without a name. `false` if there is none                                                       |
+| `resetExpression()`                              | Removes the current expression                                                                                                |
+| `setParameter(id, value)` / `resetParameter(id)` | Holds a parameter over motions until reset                                                                                    |
+| `focus(x, y)` / `resetFocus()`                   | Looks at a point, easing / looks straight ahead                                                                               |
+| `hitTest(x, y)`                                  | Names of the `model3.json` hit areas at a point                                                                               |
+| `motionGroups`, `expressionNames`                | What the model has                                                                                                            |
+| `width`, `height`                                | The model's native canvas size                                                                                                |
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first. To build and run the repo, see [DEVELOPMENT.md](https://github.com/airisu-dev/react-native-live2d-skia/blob/main/DEVELOPMENT.md).
+
+## License
+
+MIT. The Cubism SDK is not part of this package; it's under [Live2D's license](https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html).
+
+Bootstrapped with [create-nitro-module](https://github.com/patrickkabwe/create-nitro-module).

package/android/CMakeLists.txt

@@ -0,0 +1,113 @@
+project(Live2dSkia)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME Live2dSkia)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+
+# Cubism SDK for Native: proprietary, downloaded by each app. build.gradle
+# passes its folder (and checks its version), see app.plugin.js.
+if (NOT CUBISM_SDK_DIR OR NOT CUBISM_SDK_VERSION_NUMBER)
+        message(FATAL_ERROR "[react-native-live2d-skia] CUBISM_SDK_DIR isn't set: build through Gradle, "
+                "with live2dSkia.cubismSdkPath set by the react-native-live2d-skia config plugin.")
+endif()
+# The SDK's version, for cpp/cubism/CubismCompat.hpp.
+add_compile_definitions(LIVE2D_SKIA_CUBISM_SDK=${CUBISM_SDK_VERSION_NUMBER})
+
+# Cubism Core (closed source): the prebuilt static library.
+set (CUBISM_CORE_DIR "${CUBISM_SDK_DIR}/Core")
+set (CUBISM_CORE_LIB "${CUBISM_CORE_DIR}/lib/android/${ANDROID_ABI}/libLive2DCubismCore.a")
+if (NOT EXISTS "${CUBISM_CORE_LIB}")
+        message(FATAL_ERROR "[react-native-live2d-skia] Cubism Core not found for ${ANDROID_ABI} at ${CUBISM_CORE_LIB}.")
+endif()
+add_library(Live2DCubismCore STATIC IMPORTED)
+set_target_properties(Live2DCubismCore PROPERTIES IMPORTED_LOCATION "${CUBISM_CORE_LIB}")
+
+# Cubism Native Framework (motions, physics, pose, ...): the source in the same
+# SDK, so it always matches the Core.
+# Its Rendering/<backend> folders are left out: we draw with Skia
+# (see ../cpp/cubism/CubismRendererStub.cpp).
+set (CUBISM_FRAMEWORK_DIR "${CUBISM_SDK_DIR}/Framework/src")
+if (NOT EXISTS "${CUBISM_FRAMEWORK_DIR}/CubismFramework.cpp")
+        message(FATAL_ERROR "[react-native-live2d-skia] Cubism Native Framework not found at ${CUBISM_FRAMEWORK_DIR}.")
+endif()
+file(GLOB_RECURSE CUBISM_FRAMEWORK_SOURCES "${CUBISM_FRAMEWORK_DIR}/*.cpp")
+list(FILTER CUBISM_FRAMEWORK_SOURCES EXCLUDE REGEX "/Rendering/[^/]+/")
+add_library(CubismFramework STATIC ${CUBISM_FRAMEWORK_SOURCES})
+target_include_directories(CubismFramework PUBLIC "${CUBISM_FRAMEWORK_DIR}" "${CUBISM_CORE_DIR}/include")
+# Third-party code: don't flood the build log with its warnings.
+target_compile_options(CubismFramework PRIVATE -w)
+
+add_library(${PACKAGE_NAME} SHARED
+	src/main/cpp/cpp-adapter.cpp
+	../cpp/hybrid/HybridLive2dSkia.cpp
+	../cpp/hybrid/HybridLive2DModel.cpp
+	../cpp/cubism/CubismSetup.cpp
+	../cpp/cubism/CubismRendererStub.cpp
+	../cpp/cubism/Live2DUserModel.cpp
+	../cpp/cubism/Live2DUserModelAnimation.cpp
+)
+
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/Live2dSkia+autolinking.cmake)
+
+include_directories(
+        "src/main/cpp"
+        "../cpp/hybrid"
+        "../cpp/cubism"
+        "../cpp/drawing"
+        "${CUBISM_CORE_DIR}/include"
+)
+
+# Draw in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp). librnskia.so doesn't
+# export Skia, so link the same prebuilt libskia.a it's built from and use its
+# headers and defines; objects cross over through virtual calls. build.gradle
+# passes the folders of the Skia the app uses, v3 (Graphite) or v2 (Ganesh).
+# Without them, models are drawn in JS (src/drawer.ts).
+set (RN_SKIA_LIBS_ABI "${RN_SKIA_LIBS}/${ANDROID_ABI}")
+if (RN_SKIA_DIR AND EXISTS "${RN_SKIA_LIBS_ABI}/libskia.a" AND EXISTS "${RN_SKIA_DIR}/cpp/api/JsiSkCanvas.h")
+        message(STATUS "react-native-live2d-skia: drawing with Skia in C++ (${RN_SKIA_DIR}, Graphite: ${RN_SKIA_GRAPHITE})")
+        add_library(skia STATIC IMPORTED)
+        set_target_properties(skia PROPERTIES IMPORTED_LOCATION "${RN_SKIA_LIBS_ABI}/libskia.a")
+        target_sources(${PACKAGE_NAME} PRIVATE ../cpp/drawing/SkiaDrawer.cpp ../cpp/drawing/MeshCache.cpp)
+        target_include_directories(${PACKAGE_NAME} PRIVATE
+                "${RN_SKIA_DIR}/cpp/skia"
+                "${RN_SKIA_DIR}/cpp/api"
+                "${RN_SKIA_DIR}/cpp/jsi"
+                "${RN_SKIA_DIR}/cpp/rnskia"
+                "${RN_SKIA_DIR}/cpp/rnskia/values"
+                "${RN_SKIA_DIR}/cpp/utils"
+                "${RN_SKIA_DIR}/cpp"
+                "${RN_SKIA_DIR}/android/cpp/rnskia-android"
+                "${RN_SKIA_DIR}/android/cpp/jni/include"
+                "${REACT_NATIVE_DIR}/ReactCommon"
+                "${REACT_NATIVE_DIR}/ReactCommon/callinvoker")
+        # Same as the Skia package's build: struct layouts must match.
+        target_compile_definitions(${PACKAGE_NAME} PRIVATE
+                LIVE2D_SKIA=1 SK_BUILD_FOR_ANDROID
+                SK_DISABLE_LEGACY_SHAPER_FACTORY SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API
+                FOLLY_NO_CONFIG=1 FOLLY_HAVE_CLOCK_GETTIME=1 FOLLY_HAVE_MEMRCHR=1
+                FOLLY_USE_LIBCPP=1 FOLLY_MOBILE=1 ON_ANDROID ONANDROID)
+        if (RN_SKIA_GRAPHITE)
+                target_include_directories(${PACKAGE_NAME} PRIVATE "${RN_SKIA_DIR}/cpp/dawn/include")
+                target_compile_definitions(${PACKAGE_NAME} PRIVATE SK_GRAPHITE)
+        else()
+                target_compile_definitions(${PACKAGE_NAME} PRIVATE SK_GL SK_GANESH)
+        endif()
+        set (LIVE2D_SKIA_LIBS skia)
+else()
+        message(STATUS "react-native-live2d-skia: no Skia to draw with in C++, drawing in JS")
+endif()
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        CubismFramework
+        Live2DCubismCore
+        ${LIVE2D_SKIA_LIBS}
+        android                                   # <-- Android core
+)