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

package/android/src/main/java/com/live2dskia/Live2dSkiaPackage.kt

@@ -0,0 +1,20 @@
+package com.live2dskia;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.BaseReactPackage;
+import com.margelo.nitro.live2dskia.Live2dSkiaOnLoad;
+
+
+public class Live2dSkiaPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+
+  companion object {
+    init {
+      Live2dSkiaOnLoad.initializeNative();
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1,2 @@
+// Expo CLI looks for this file. The plugin is in plugin/src, built to plugin/build.
+module.exports = require('./plugin/build').default

package/cli/build/index.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = void 0;
+exports.parseArgs = parseArgs;
+// @airisu-dev/react-native-live2d-skia fetch-sdk --accept-license [--sdk-version <version>] [--out <dir>] [--keep-zip]
+//
+// Downloads Cubism SDK for Native into <dir> (default ./vendor/CubismSdkForNative), for the
+// config plugin's `cubismSdkPath`. The Core is proprietary and not shipped: downloading means accepting Live2D's license.
+const child_process_1 = require("child_process");
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// The SDK versions the package supports. Two levels up from both cli/src and cli/build.
+const { cubismSdk } = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+const VERSIONS = Object.keys(cubismSdk.versions);
+const sdkUrl = (version) => `https://cubism.live2d.com/sdk-native/bin/CubismSdkForNative-${version}.zip`;
+const DEFAULT_OUT = 'vendor/CubismSdkForNative';
+const LICENSES = [
+    'Live2D Proprietary Software License (Cubism Core): https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html',
+    'Live2D Open Software License (Cubism Native Framework): https://www.live2d.com/eula/live2d-open-software-license-agreement_en.html',
+    'Cubism SDK Release License (required to publish apps, for businesses above 10M JPY a year): https://www.live2d.com/en/sdk/license/',
+];
+function usage() {
+    console.log(`Usage: @airisu-dev/react-native-live2d-skia fetch-sdk --accept-license [--sdk-version <version>] [--out <dir>] [--keep-zip]
+
+Downloads Cubism SDK for Native from Live2D into <dir>
+(default: ./${DEFAULT_OUT}). Then set it in app.json:
+
+  "plugins": [["@airisu-dev/react-native-live2d-skia", { "cubismSdkPath": "./${DEFAULT_OUT}" }]]
+
+--accept-license  Required: you accept Live2D's license terms:
+${LICENSES.map((l) => `                    - ${l}`).join('\n')}
+--sdk-version     Which version: ${VERSIONS.join(', ')} (default: ${cubismSdk.latest}).
+--out <dir>       Where to extract the SDK.
+--keep-zip        Keep the downloaded zip next to <dir> (e.g. to cache it on CI).`);
+}
+function fail(message) {
+    console.error(`error: ${message}`);
+    process.exit(1);
+}
+function parseArgs(argv) {
+    const args = {
+        command: argv[0] === '--help' || argv[0] === '-h' ? 'help' : argv[0],
+        acceptLicense: false,
+        version: cubismSdk.latest,
+        out: DEFAULT_OUT,
+        keepZip: false,
+    };
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        if (arg === '--accept-license')
+            args.acceptLicense = true;
+        else if (arg === '--keep-zip')
+            args.keepZip = true;
+        else if (arg === '--sdk-version' && next) {
+            args.version = next;
+            i++;
+        }
+        else if (arg === '--out' && next) {
+            args.out = next;
+            i++;
+        }
+        else if (arg === '--help' || arg === '-h')
+            args.command = 'help';
+        else
+            throw new Error(`unknown option ${arg}`);
+    }
+    return args;
+}
+const sha256 = (file) => crypto_1.default.createHash('sha256').update(fs_1.default.readFileSync(file)).digest('hex');
+exports.sha256 = sha256;
+async function download(url, file) {
+    console.log(`Downloading ${url}`);
+    const response = await fetch(url);
+    if (!response.ok)
+        fail(`download failed: HTTP ${response.status}`);
+    fs_1.default.writeFileSync(file, Buffer.from(await response.arrayBuffer()));
+}
+// unzip where it exists (macOS, most Linux), else tar, which reads zips on
+// Windows 10+ (bsdtar) and macOS.
+function extract(zip, dir) {
+    const hasUnzip = !(0, child_process_1.spawnSync)('unzip', ['-v'], { stdio: 'ignore' }).error;
+    const [cmd, args] = hasUnzip
+        ? ['unzip', ['-q', zip, '-d', dir]]
+        : ['tar', ['-xf', zip, '-C', dir]];
+    const result = (0, child_process_1.spawnSync)(cmd, args, { stdio: 'inherit' });
+    if (result.error || result.status !== 0) {
+        fail(`couldn't extract ${zip} with ${cmd}`);
+    }
+}
+async function fetchSdk({ acceptLicense, version, out, keepZip }) {
+    if (!acceptLicense) {
+        console.error("Cubism SDK for Native is Live2D's software. Downloading it means accepting:\n" +
+            LICENSES.map((l) => `  - ${l}`).join('\n') +
+            '\nRe-run with --accept-license to accept them and download.');
+        process.exit(1);
+    }
+    const expected = cubismSdk.versions[version]?.sha256;
+    if (!expected)
+        fail(`Cubism SDK for Native ${version} isn't supported: use ${VERSIONS.join(', ')}`);
+    const sdkDir = path_1.default.resolve(out);
+    const versionFile = path_1.default.join(sdkDir, '.version');
+    if (fs_1.default.existsSync(versionFile) && fs_1.default.readFileSync(versionFile, 'utf8').trim() === version) {
+        console.log(`Cubism SDK for Native ${version} already in ${sdkDir}`);
+        return;
+    }
+    const zip = `${sdkDir}-${version}.zip`;
+    fs_1.default.mkdirSync(path_1.default.dirname(sdkDir), { recursive: true });
+    if (!fs_1.default.existsSync(zip) || (0, exports.sha256)(zip) !== expected) {
+        await download(sdkUrl(version), zip);
+    }
+    const actual = (0, exports.sha256)(zip);
+    if (actual !== expected) {
+        fs_1.default.rmSync(zip, { force: true });
+        fail(`checksum mismatch for ${zip} (expected ${expected}, got ${actual})`);
+    }
+    // Extract next to the destination, so the move is a rename on the same drive.
+    const tmp = `${sdkDir}.extracting`;
+    fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    fs_1.default.mkdirSync(tmp);
+    try {
+        extract(zip, tmp);
+        fs_1.default.rmSync(sdkDir, { recursive: true, force: true });
+        fs_1.default.renameSync(path_1.default.join(tmp, `CubismSdkForNative-${version}`), sdkDir);
+    }
+    finally {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    }
+    fs_1.default.writeFileSync(versionFile, `${version}\n`);
+    if (!keepZip)
+        fs_1.default.rmSync(zip, { force: true });
+    const relative = path_1.default.relative(process.cwd(), sdkDir).split(path_1.default.sep).join('/');
+    console.log(`Extracted Cubism SDK for Native ${version} to ${sdkDir}
+
+Next:
+  - Keep it out of public repos: add "/${relative}/" to .gitignore.
+  - Set it in app.json: "plugins": [["@airisu-dev/react-native-live2d-skia", { "cubismSdkPath": "./${relative}" }]]
+  - On EAS Build, run this command in an "eas-build-post-install" script.`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.command === 'fetch-sdk')
+        await fetchSdk(args);
+    else {
+        usage();
+        if (args.command && args.command !== 'help')
+            process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((e) => fail(e instanceof Error ? e.message : String(e)));
+}

package/cpp/cubism/CubismCompat.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+// Differences between the Cubism SDK for Native versions react-native-live2d-skia builds
+// against (cubismSdk.versions in package.json). build.gradle and the podspec
+// pass the SDK's version as LIVE2D_SKIA_CUBISM_SDK: major * 10000 + release *
+// 100 + patch, so 5-r.4.1 is 50401. Version-specific calls go here, behind
+// #if on it (older SDK versions).
+
+#include "Live2DCubismCore.hpp"
+
+#ifndef LIVE2D_SKIA_CUBISM_SDK
+#error "[react-native-live2d-skia] LIVE2D_SKIA_CUBISM_SDK isn't set: build through Gradle or CocoaPods."
+#endif
+
+#if LIVE2D_SKIA_CUBISM_SDK < 50500
+#error "[react-native-live2d-skia] Cubism SDK for Native before 5-r.5 isn't supported."
+#endif
+
+namespace margelo::nitro::live2dskia::cubism {
+
+// Drawable render orders. Named csmGetDrawableRenderOrders before 5-r.5.
+inline const int* renderOrders(const Live2D::Cubism::Core::csmModel* model) {
+    return Live2D::Cubism::Core::csmGetRenderOrders(model);
+}
+
+} // namespace margelo::nitro::live2dskia::cubism

package/cpp/cubism/CubismHelpers.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <stdexcept>
+#include <string>
+#include "CubismFramework.hpp"
+#include "Id/CubismIdManager.hpp"
+#include "Utils/CubismJson.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+inline const Live2D::Cubism::Framework::csmByte* bytesOf(const std::string& s) {
+    return reinterpret_cast<const Live2D::Cubism::Framework::csmByte*>(s.data());
+}
+
+// The Framework's loaders don't check for parse errors and crash on invalid
+// JSON, so parse it once up front and throw instead.
+inline void requireValidJson(const std::string& json, const std::string& what) {
+    using namespace Live2D::Cubism::Framework;
+    Utils::CubismJson* parsed = Utils::CubismJson::Create(bytesOf(json), static_cast<csmSizeInt>(json.size()));
+    if (!parsed) throw std::runtime_error("Live2D: invalid " + what);
+    Utils::CubismJson::Delete(parsed);
+}
+
+inline Live2D::Cubism::Framework::CubismIdHandle idOf(const Live2D::Cubism::Framework::csmChar* name) {
+    return Live2D::Cubism::Framework::CubismFramework::GetIdManager()->GetId(name);
+}
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/CubismRendererStub.cpp

@@ -0,0 +1,14 @@
+// The Cubism Framework references a few renderer entry points that each
+// Rendering/<backend> normally defines. We draw with Skia instead, so no
+// backend is compiled and these are stubbed out.
+#include "Rendering/CubismRenderer.hpp"
+
+namespace Live2D::Cubism::Framework::Rendering {
+
+CubismRenderer* CubismRenderer::Create(csmUint32, csmUint32) {
+    return nullptr;
+}
+
+void CubismRenderer::StaticRelease() {}
+
+} // namespace Live2D::Cubism::Framework::Rendering

package/cpp/cubism/CubismSetup.cpp

@@ -0,0 +1,54 @@
+#include "CubismSetup.hpp"
+#include <cstdio>
+#include <cstdlib>
+#include <mutex>
+#include "CubismFramework.hpp"
+#include "ICubismAllocator.hpp"
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+
+namespace margelo::nitro::live2dskia {
+
+namespace {
+
+using namespace Live2D::Cubism::Framework;
+
+class Allocator : public ICubismAllocator {
+    public:
+        void* Allocate(const csmSizeType size) override { return std::malloc(size); }
+        void Deallocate(void* memory) override { std::free(memory); }
+        void* AllocateAligned(const csmSizeType size, const csmUint32 alignment) override {
+            void* p = nullptr;
+            // posix_memalign needs at least pointer alignment.
+            const size_t a = alignment < sizeof(void*) ? sizeof(void*) : alignment;
+            return posix_memalign(&p, a, size) == 0 ? p : nullptr;
+        }
+        void DeallocateAligned(void* alignedMemory) override { std::free(alignedMemory); }
+};
+
+void log(const char* message) {
+#ifdef __ANDROID__
+    __android_log_print(ANDROID_LOG_INFO, "Live2dSkia", "%s", message);
+#else
+    std::printf("[Live2dSkia] %s", message);
+#endif
+}
+
+} // namespace
+
+void ensureCubismFramework() {
+    static std::once_flag once;
+    std::call_once(once, [] {
+        // Both live for the whole process: the Framework keeps pointers to them.
+        static Allocator allocator;
+        static CubismFramework::Option option{};
+        option.LogFunction = log;
+        option.LoggingLevel = CubismFramework::Option::LogLevel_Info;
+        CubismFramework::StartUp(&allocator, &option);
+        CubismFramework::Initialize();
+    });
+}
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/CubismSetup.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace margelo::nitro::live2dskia {
+
+// Starts up and initializes the Cubism Framework once per process.
+// Safe to call from any thread, any number of times.
+void ensureCubismFramework();
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/HeldParameterUpdater.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <map>
+#include "CubismModelSettingJson.hpp"
+#include "Motion/ICubismUpdater.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+// Applies setParameter values every update, after look and breath (so they
+// can be overridden) and before physics (so hair and clothes follow).
+class HeldParameterUpdater : public Live2D::Cubism::Framework::ICubismUpdater {
+    public:
+        explicit HeldParameterUpdater(const std::map<Live2D::Cubism::Framework::CubismIdHandle, float>& values)
+            : ICubismUpdater(Live2D::Cubism::Framework::CubismUpdateOrder_Breath + 50), _values(values) {}
+
+        void OnLateUpdate(Live2D::Cubism::Framework::CubismModel* model, Live2D::Cubism::Framework::csmFloat32) override {
+            for (const auto& [id, value] : _values) {
+                model->SetParameterValue(id, value);
+            }
+        }
+
+    private:
+        const std::map<Live2D::Cubism::Framework::CubismIdHandle, float>& _values;
+};
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/Live2DUserModel.cpp

@@ -0,0 +1,125 @@
+#include "Live2DUserModel.hpp"
+#include <stdexcept>
+#include "CubismDefaultParameterId.hpp"
+#include "CubismHelpers.hpp"
+#include "Effect/CubismBreath.hpp"
+#include "Effect/CubismEyeBlink.hpp"
+#include "Effect/CubismLook.hpp"
+#include "HeldParameterUpdater.hpp"
+#include "Motion/CubismBreathUpdater.hpp"
+#include "Motion/CubismExpressionUpdater.hpp"
+#include "Motion/CubismEyeBlinkUpdater.hpp"
+#include "Motion/CubismLookUpdater.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+using namespace Live2D::Cubism::Framework;
+
+Live2DUserModel::Live2DUserModel(const uint8_t* moc, size_t mocSize, const std::string& settingsJson) {
+    if (moc == nullptr || mocSize == 0) {
+        throw std::runtime_error("Live2D: moc is empty");
+    }
+    LoadModel(moc, static_cast<csmSizeInt>(mocSize), true);
+    if (_model == nullptr) {
+        throw std::runtime_error("Live2D: moc is invalid, corrupted or newer than this Cubism Core");
+    }
+
+    requireValidJson(settingsJson, "model3.json");
+    _setting = CSM_NEW CubismModelSettingJson(bytesOf(settingsJson), static_cast<csmSizeInt>(settingsJson.size()));
+
+    for (csmInt32 i = 0; i < _setting->GetEyeBlinkParameterCount(); ++i) {
+        _eyeBlinkIds.PushBack(_setting->GetEyeBlinkParameterId(i));
+    }
+    for (csmInt32 i = 0; i < _setting->GetLipSyncParameterCount(); ++i) {
+        _lipSyncIds.PushBack(_setting->GetLipSyncParameterId(i));
+    }
+
+    if (_eyeBlinkIds.GetSize() > 0) {
+        _eyeBlink = CubismEyeBlink::Create(_setting);
+        _updateScheduler.AddUpdatableList(CSM_NEW CubismEyeBlinkUpdater(_motionUpdated, *_eyeBlink));
+    }
+
+    _breath = CubismBreath::Create();
+    csmVector<CubismBreath::BreathParameterData> breath;
+    breath.PushBack(CubismBreath::BreathParameterData(idOf(DefaultParameterId::ParamAngleX), 0.0f, 15.0f, 6.5345f, 0.5f));
+    breath.PushBack(CubismBreath::BreathParameterData(idOf(DefaultParameterId::ParamAngleY), 0.0f, 8.0f, 3.5345f, 0.5f));
+    breath.PushBack(CubismBreath::BreathParameterData(idOf(DefaultParameterId::ParamAngleZ), 0.0f, 10.0f, 5.5345f, 0.5f));
+    breath.PushBack(CubismBreath::BreathParameterData(idOf(DefaultParameterId::ParamBodyAngleX), 0.0f, 4.0f, 15.5345f, 0.5f));
+    breath.PushBack(CubismBreath::BreathParameterData(idOf(DefaultParameterId::ParamBreath), 0.5f, 0.5f, 3.2345f, 0.5f));
+    _breath->SetParameters(breath);
+    _updateScheduler.AddUpdatableList(CSM_NEW CubismBreathUpdater(*_breath));
+
+    _updateScheduler.AddUpdatableList(CSM_NEW CubismExpressionUpdater(*_expressionManager));
+
+    _look = CubismLook::Create();
+    csmVector<CubismLook::LookParameterData> look;
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamAngleX), 30.0f));
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamAngleY), 0.0f, 30.0f));
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamAngleZ), 0.0f, 0.0f, -30.0f));
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamBodyAngleX), 10.0f));
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamEyeBallX), 1.0f));
+    look.PushBack(CubismLook::LookParameterData(idOf(DefaultParameterId::ParamEyeBallY), 0.0f, 1.0f));
+    _look->SetParameters(look);
+    _updateScheduler.AddUpdatableList(CSM_NEW CubismLookUpdater(*_look, *_dragManager));
+
+    _updateScheduler.AddUpdatableList(CSM_NEW HeldParameterUpdater(_heldParameters));
+
+    _updateScheduler.SortUpdatableList();
+    _model->SaveParameters();
+}
+
+Live2DUserModel::~Live2DUserModel() {
+    // Stop motions before deleting them: the motion manager still points at them.
+    if (_motionManager) _motionManager->StopAllMotions();
+    for (auto& [_, motion] : _motions) {
+        ACubismMotion::Delete(motion);
+    }
+    if (_expressionManager) _expressionManager->StopAllMotions();
+    for (auto& [_, expression] : _expressions) {
+        ACubismMotion::Delete(expression);
+    }
+    CSM_DELETE(_setting);
+}
+
+void Live2DUserModel::setParameter(const std::string& id, float value) {
+    _heldParameters[idOf(id.c_str())] = value;
+}
+
+void Live2DUserModel::clearParameter(const std::string& id) {
+    _heldParameters.erase(idOf(id.c_str()));
+}
+
+void Live2DUserModel::focus(float x, float y) {
+    SetDragging(x, y);
+}
+
+std::vector<std::string> Live2DUserModel::hitTest(float x, float y) {
+    std::vector<std::string> hits;
+    // Like the SDK sample: a fading-in or transparent model can't be hit.
+    if (_model->GetModelOpacity() < 1) return hits;
+    for (csmInt32 i = 0; i < _setting->GetHitAreasCount(); ++i) {
+        if (IsHit(_setting->GetHitAreaId(i), x, y)) {
+            hits.emplace_back(_setting->GetHitAreaName(i));
+        }
+    }
+    return hits;
+}
+
+void Live2DUserModel::update(float deltaSeconds) {
+    // Same order as the SDK sample's LAppModel::Update.
+    _motionUpdated = false;
+    _model->LoadParameters();
+    if (_motionManager->IsFinished()) {
+        startRandomMotion("Idle", PriorityIdle);
+    } else {
+        _motionUpdated = _motionManager->UpdateMotion(_model, deltaSeconds);
+    }
+    _model->SaveParameters();
+
+    // Eye blink (unless a motion moved the eyes), expression, look, breath,
+    // held parameters, physics, pose.
+    _updateScheduler.OnLateUpdate(_model, deltaSeconds);
+    _model->Update();
+}
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/Live2DUserModel.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include <map>
+#include <string>
+#include <vector>
+#include "CubismModelSettingJson.hpp"
+#include "Model/CubismUserModel.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+namespace csm = Live2D::Cubism::Framework;
+
+// Drives a model with the Cubism Framework, like the SDK sample's LAppModel,
+// without its renderer: drawing is done with Skia from the drawable data.
+// Never call CreateRenderer() on it (see CubismRendererStub.cpp).
+// Not thread-safe: HybridLive2DModel serializes calls.
+class Live2DUserModel : public csm::CubismUserModel {
+    public:
+        enum Priority { PriorityIdle = 1, PriorityNormal = 2, PriorityForce = 3 };
+
+        // Throws std::runtime_error if the moc or the settings can't be loaded.
+        Live2DUserModel(const uint8_t* moc, size_t mocSize, const std::string& settingsJson);
+        ~Live2DUserModel() override;
+
+        csm::CubismModel* model() const { return _model; }
+
+        void loadPhysics(const std::string& json);
+        void loadPose(const std::string& json);
+        void loadMotion(const std::string& group, int index, const std::string& json);
+        bool startMotion(const std::string& group, int index, Priority priority);
+        bool startRandomMotion(const std::string& group, Priority priority);
+        void loadExpression(const std::string& name, const std::string& json);
+        bool setExpression(const std::string& name);
+        bool setRandomExpression();
+        void clearExpression();
+        void setParameter(const std::string& id, float value);
+        void clearParameter(const std::string& id);
+        // -1..1 on each axis, y-up.
+        void focus(float x, float y);
+        // Hit area names containing the point (model units, y-up).
+        std::vector<std::string> hitTest(float x, float y);
+        void update(float deltaSeconds);
+
+    private:
+        static std::string motionKey(const std::string& group, int index);
+
+        csm::CubismModelSettingJson* _setting = nullptr;
+        csm::csmVector<csm::CubismIdHandle> _eyeBlinkIds;
+        csm::csmVector<csm::CubismIdHandle> _lipSyncIds;
+        std::map<std::string, csm::ACubismMotion*> _motions;
+        std::map<std::string, csm::ACubismMotion*> _expressions;
+        // Set by setParameter, applied every update.
+        std::map<csm::CubismIdHandle, float> _heldParameters;
+        // Read by the eye blink updater: no blinking while a motion moves the eyes.
+        csm::csmBool _motionUpdated = false;
+};
+
+} // namespace margelo::nitro::live2dskia

package/cpp/cubism/Live2DUserModelAnimation.cpp

@@ -0,0 +1,107 @@
+// The loadable animation data of Live2DUserModel: physics, pose, motions and expressions.
+#include "Live2DUserModel.hpp"
+#include <cstdlib>
+#include <iterator>
+#include <stdexcept>
+#include "CubismHelpers.hpp"
+#include "Motion/CubismMotion.hpp"
+#include "Motion/CubismPhysicsUpdater.hpp"
+#include "Motion/CubismPoseUpdater.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+using namespace Live2D::Cubism::Framework;
+
+void Live2DUserModel::loadPhysics(const std::string& json) {
+    if (_physics) throw std::runtime_error("Live2D: physics already loaded");
+    requireValidJson(json, "physics3.json");
+    LoadPhysics(bytesOf(json), static_cast<csmSizeInt>(json.size()));
+    if (!_physics) throw std::runtime_error("Live2D: invalid physics3.json");
+    _updateScheduler.AddUpdatableList(CSM_NEW CubismPhysicsUpdater(*_physics));
+    _updateScheduler.SortUpdatableList();
+}
+
+void Live2DUserModel::loadPose(const std::string& json) {
+    if (_pose) throw std::runtime_error("Live2D: pose already loaded");
+    requireValidJson(json, "pose3.json");
+    LoadPose(bytesOf(json), static_cast<csmSizeInt>(json.size()));
+    if (!_pose) throw std::runtime_error("Live2D: invalid pose3.json");
+    _updateScheduler.AddUpdatableList(CSM_NEW CubismPoseUpdater(*_pose));
+    _updateScheduler.SortUpdatableList();
+}
+
+void Live2DUserModel::loadMotion(const std::string& group, int index, const std::string& json) {
+    const std::string key = motionKey(group, index);
+    requireValidJson(json, "motion3.json for " + key);
+    auto* motion = static_cast<CubismMotion*>(LoadMotion(
+        bytesOf(json), static_cast<csmSizeInt>(json.size()), key.c_str(),
+        nullptr, nullptr, _setting, group.c_str(), index));
+    if (!motion) throw std::runtime_error("Live2D: invalid motion3.json for " + key);
+    motion->SetEffectIds(_eyeBlinkIds, _lipSyncIds);
+
+    auto it = _motions.find(key);
+    if (it != _motions.end()) {
+        _motionManager->StopAllMotions();
+        ACubismMotion::Delete(it->second);
+    }
+    _motions[key] = motion;
+}
+
+bool Live2DUserModel::startMotion(const std::string& group, int index, Priority priority) {
+    auto it = _motions.find(motionKey(group, index));
+    if (it == _motions.end()) return false;
+
+    if (priority == PriorityForce) {
+        _motionManager->SetReservePriority(priority);
+    } else if (!_motionManager->ReserveMotion(priority)) {
+        return false;
+    }
+    // autoDelete = false: the motion is reused, and freed in the destructor.
+    _motionManager->StartMotionPriority(it->second, false, priority);
+    return true;
+}
+
+bool Live2DUserModel::startRandomMotion(const std::string& group, Priority priority) {
+    int count = 0;
+    while (_motions.count(motionKey(group, count))) ++count;
+    if (count == 0) return false;
+    return startMotion(group, std::rand() % count, priority);
+}
+
+void Live2DUserModel::loadExpression(const std::string& name, const std::string& json) {
+    requireValidJson(json, "exp3.json for " + name);
+    ACubismMotion* expression = LoadExpression(bytesOf(json), static_cast<csmSizeInt>(json.size()), name.c_str());
+    if (!expression) throw std::runtime_error("Live2D: invalid exp3.json for " + name);
+
+    auto it = _expressions.find(name);
+    if (it != _expressions.end()) {
+        _expressionManager->StopAllMotions();
+        ACubismMotion::Delete(it->second);
+    }
+    _expressions[name] = expression;
+}
+
+bool Live2DUserModel::setExpression(const std::string& name) {
+    auto it = _expressions.find(name);
+    if (it == _expressions.end()) return false;
+    // autoDelete = false: the expression is reused, and freed in the destructor.
+    _expressionManager->StartMotion(it->second, false);
+    return true;
+}
+
+bool Live2DUserModel::setRandomExpression() {
+    if (_expressions.empty()) return false;
+    auto it = _expressions.begin();
+    std::advance(it, std::rand() % _expressions.size());
+    return setExpression(it->first);
+}
+
+void Live2DUserModel::clearExpression() {
+    _expressionManager->StopAllMotions();
+}
+
+std::string Live2DUserModel::motionKey(const std::string& group, int index) {
+    return group + "_" + std::to_string(index);
+}
+
+} // namespace margelo::nitro::live2dskia

package/cpp/drawing/JsiUnwrap.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#if LIVE2D_SKIA
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::live2dskia {
+
+namespace jsi = facebook::jsi;
+
+// The wrapper behind a react-native-skia JS object. jsi's hasNativeState<T>
+// uses dynamic_cast, which can't be relied on across shared libraries, so check
+// for any native state and cast: only react-native-live2d-skia's own JS passes these in.
+template <typename T>
+std::shared_ptr<T> unwrap(jsi::Runtime& runtime, const jsi::Value& value, const char* what) {
+    if (!value.isObject()) throw jsi::JSError(runtime, std::string("Live2D: expected ") + what);
+    jsi::Object object = value.getObject(runtime);
+    if (!object.hasNativeState(runtime)) throw jsi::JSError(runtime, std::string("Live2D: expected ") + what);
+    return std::static_pointer_cast<T>(object.getNativeState(runtime));
+}
+
+} // namespace margelo::nitro::live2dskia
+
+#endif // LIVE2D_SKIA