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

package/android/build.gradle

@@ -0,0 +1,223 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/Live2dSkia+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+// Cubism SDK for Native: proprietary, so each app downloads it from Live2D and
+// sets its folder (app.plugin.js writes live2dSkia.cubismSdkPath, relative to android/).
+def findCubismSdk() {
+  def configured = System.getenv("LIVE2D_SKIA_CUBISM_SDK") ?: rootProject.findProperty("live2dSkia.cubismSdkPath")
+  if (!configured) {
+    throw new GradleException("[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.")
+  }
+  def dir = rootProject.file(configured)
+  def info = new File(dir, "cubism-info.yml")
+  if (!info.exists()) {
+    throw new GradleException("[react-native-live2d-skia] Cubism SDK for Native not found at ${dir} (no cubism-info.yml). " +
+      "Download it with `@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm).")
+  }
+  def matcher = info.text =~ /(?m)^version:\s*(\S+)/
+  def version = matcher.find() ? matcher.group(1) : "unknown"
+  checkCubismSdkVersion(version, dir)
+  return [dir: dir.absolutePath.replace("\\", "/"), version: version]
+}
+
+// A Cubism SDK version as a number: major * 10000 + release * 100 + patch, so
+// 5-r.4.1 is 50401 (a -beta suffix is ignored). Null if it isn't one.
+def cubismSdkVersionNumber(String version) {
+  def m = version =~ /^(\d+)-r\.(\d+)(?:\.(\d+))?/
+  return m.find() ? m.group(1).toInteger() * 10000 + m.group(2).toInteger() * 100 + (m.group(3) ?: "0").toInteger() : null
+}
+
+// Listed versions (cubismSdk.versions in package.json) are supported. A newer
+// release of a listed major only warns; anything else fails.
+def checkCubismSdkVersion(String version, File dir) {
+  def listed = new groovy.json.JsonSlurper().parse(file("../package.json")).cubismSdk.versions.keySet()
+  if (listed.contains(version)) return
+  def number = cubismSdkVersionNumber(version)
+  def newestOfMajor = number == null ? null : listed.collect { cubismSdkVersionNumber(it) }
+    .findAll { it.intdiv(10000) == number.intdiv(10000) }.max()
+  if (newestOfMajor == null || number < newestOfMajor) {
+    throw new GradleException("[react-native-live2d-skia] Cubism SDK for Native ${version} at ${dir} isn't supported: use ${listed.join(', ')}.")
+  }
+  logger.warn("[react-native-live2d-skia] Cubism SDK for Native ${version} found, tested with ${listed.join(', ')}.")
+}
+
+// The folder of a node package, as `from` resolves it. Null if it isn't installed.
+def resolveNodePackage(String name, File from) {
+  def process = ["node", "-p",
+    "require('path').dirname(require.resolve(process.argv[1] + '/package.json', { paths: [process.argv[2]] }))",
+    name, from.absolutePath].execute()
+  def out = process.text.trim()
+  return process.waitFor() == 0 && out ? new File(out) : null
+}
+
+// Drawing in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp) needs the headers,
+// defines and prebuilt libskia.a of the Skia the app uses: react-native-skia
+// (v3, Graphite) or @shopify/react-native-skia (v2, Ganesh), as app.plugin.js
+// found in the app's package.json (live2dSkia.skiaPackage). Resolved from the
+// app, since a monorepo can have both installed. No arguments: drawn in JS.
+def skiaCmakeArguments() {
+  def name = rootProject.findProperty("live2dSkia.skiaPackage")
+  if (!name) return []
+  def appDir = rootProject.projectDir.parentFile
+  def skiaDir = resolveNodePackage(name, appDir)
+  def graphite = name == "react-native-skia"
+  def libsDir = skiaDir ? resolveNodePackage(graphite ? "react-native-skia-graphite-android" : "react-native-skia-android", skiaDir) : null
+  def reactNativeDir = resolveNodePackage("react-native", appDir)
+  if (!skiaDir || !libsDir || !reactNativeDir) {
+    logger.warn("[react-native-live2d-skia] ${name} or its Android binaries not found from ${appDir}: drawing in JS.")
+    return []
+  }
+  return ["-DRN_SKIA_DIR=${skiaDir.absolutePath.replace("\\", "/")}",
+          "-DRN_SKIA_LIBS=${new File(libsDir, "libs").absolutePath.replace("\\", "/")}",
+          "-DRN_SKIA_GRAPHITE=${graphite ? "ON" : "OFF"}",
+          "-DREACT_NATIVE_DIR=${reactNativeDir.absolutePath.replace("\\", "/")}"]
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Live2dSkia_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Live2dSkia_" + name]).toInteger()
+}
+
+android {
+  namespace "com.live2dskia"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        def cubismSdk = findCubismSdk()
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+          "-DCUBISM_SDK_DIR=${cubismSdk.dir}",
+          "-DCUBISM_SDK_VERSION_NUMBER=${cubismSdkVersionNumber(cubismSdk.version)}", *skiaCmakeArguments()
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+        "META-INF",
+        "META-INF/**",
+        "**/libc++_shared.so",
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libfolly_json.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libhermes.so",
+        "**/libhermes-executor-debug.so",
+        "**/libhermes_executor.so",
+        "**/libreactnative.so",
+        "**/libreactnativejni.so",
+        "**/libturbomodulejsijni.so",
+        "**/libreact_nativemodule_core.so",
+        "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Live2dSkia"
+    codegenJavaPackageName = "com.live2dskia"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Live2dSkia_kotlinVersion=2.1.20
+Live2dSkia_minSdkVersion=23
+Live2dSkia_targetSdkVersion=35
+Live2dSkia_compileSdkVersion=34
+Live2dSkia_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "Live2dSkiaOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::live2dskia::registerAllNatives();
+  });
+}

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