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

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

package/cpp/drawing/MeshCache.cpp

@@ -0,0 +1,75 @@
+#if LIVE2D_SKIA
+
+#include "MeshCache.hpp"
+#include <chrono>
+#include <cstring>
+
+namespace margelo::nitro::live2dskia {
+
+using namespace Live2D::Cubism::Core;
+
+namespace {
+
+double millisecondsSince(std::chrono::steady_clock::time_point start) {
+    return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
+}
+
+} // namespace
+
+void MeshCache::setTextureSizes(std::vector<SkISize> sizes) {
+    _textureSizes = std::move(sizes);
+    _meshes.clear();
+}
+
+void MeshCache::resize(size_t drawableCount) {
+    if (_meshes.size() != drawableCount) _meshes.resize(drawableCount);
+}
+
+void MeshCache::resetStats() {
+    _meshesBuilt = 0;
+    _meshMs = 0;
+}
+
+const SkVertices* MeshCache::meshOf(const csmModel* model, int i, const CanvasInfo& info) {
+    const int vertexCount = csmGetDrawableVertexCounts(model)[i];
+    const int indexCount = csmGetDrawableIndexCounts(model)[i];
+    const int texture = csmGetDrawableTextureIndices(model)[i];
+    if (vertexCount == 0 || indexCount == 0 || texture < 0 ||
+        texture >= static_cast<int>(_textureSizes.size())) {
+        return nullptr;
+    }
+    Mesh& mesh = _meshes[i];
+    const csmVector2* positions = csmGetDrawableVertexPositions(model)[i];
+    if (mesh.vertices && mesh.positions.size() == static_cast<size_t>(vertexCount) &&
+        std::memcmp(mesh.positions.data(), positions, vertexCount * sizeof(csmVector2)) == 0) {
+        return mesh.vertices.get();
+    }
+
+    const auto start = std::chrono::steady_clock::now();
+    if (mesh.texCoords.size() != static_cast<size_t>(vertexCount)) {
+        const csmVector2* uvs = csmGetDrawableVertexUvs(model)[i];
+        const SkISize size = _textureSizes[texture];
+        mesh.texCoords.resize(vertexCount);
+        for (int v = 0; v < vertexCount; ++v) {
+            // Cubism UVs are v-up.
+            mesh.texCoords[v] = {uvs[v].X * size.width(), (1 - uvs[v].Y) * size.height()};
+        }
+    }
+    _points.resize(vertexCount);
+    for (int v = 0; v < vertexCount; ++v) {
+        // Cubism is y-up in model units; Skia is y-down in pixels.
+        _points[v] = {info.originX + positions[v].X * info.pixelsPerUnit,
+                      info.originY - positions[v].Y * info.pixelsPerUnit};
+    }
+    mesh.vertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode, vertexCount, _points.data(),
+                                         mesh.texCoords.data(), nullptr, indexCount,
+                                         csmGetDrawableIndices(model)[i]);
+    mesh.positions.assign(positions, positions + vertexCount);
+    _meshesBuilt++;
+    _meshMs += millisecondsSince(start);
+    return mesh.vertices.get();
+}
+
+} // namespace margelo::nitro::live2dskia
+
+#endif // LIVE2D_SKIA

package/cpp/drawing/MeshCache.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#if LIVE2D_SKIA
+
+#include <vector>
+#include "SkiaDrawer.hpp"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkVertices.h"
+
+namespace margelo::nitro::live2dskia {
+
+// One Skia mesh per drawable, rebuilt only when the drawable's vertices moved.
+class MeshCache {
+    public:
+        // Texture coordinates depend on the texture sizes, so this drops every mesh.
+        void setTextureSizes(std::vector<SkISize> sizes);
+        void resize(size_t drawableCount);
+        void resetStats();
+
+        // Returns the drawable's mesh, rebuilt if its vertices moved; null if it has none.
+        const SkVertices* meshOf(const Live2D::Cubism::Core::csmModel* model, int i, const CanvasInfo& info);
+
+        int meshesBuilt() const { return _meshesBuilt; }
+        double meshMs() const { return _meshMs; }
+
+    private:
+        struct Mesh {
+            sk_sp<SkVertices> vertices;
+            // Model-space positions the mesh was built from, to detect changes.
+            std::vector<Live2D::Cubism::Core::csmVector2> positions;
+            // Texture coordinates in pixels, built once.
+            std::vector<SkPoint> texCoords;
+        };
+
+        std::vector<SkISize> _textureSizes;
+        std::vector<Mesh> _meshes;
+        std::vector<SkPoint> _points; // scratch
+        int _meshesBuilt = 0;
+        double _meshMs = 0;
+};
+
+} // namespace margelo::nitro::live2dskia
+
+#endif // LIVE2D_SKIA

package/cpp/drawing/SkiaDrawer.cpp

@@ -0,0 +1,138 @@
+#if LIVE2D_SKIA
+
+#include "SkiaDrawer.hpp"
+#include "CubismCompat.hpp"
+#include <algorithm>
+#include <numeric>
+#include "JsiSkCanvas.h"
+#include "JsiSkShader.h"
+#include "JsiUnwrap.hpp"
+#include "MeshCache.hpp"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkShader.h"
+#include "include/core/SkVertices.h"
+
+namespace margelo::nitro::live2dskia {
+
+using namespace Live2D::Cubism::Core;
+
+namespace {
+
+SkBlendMode blendModeOf(csmFlags constantFlags) {
+    if (constantFlags & csmBlendAdditive) return SkBlendMode::kPlus;
+    if (constantFlags & csmBlendMultiplicative) return SkBlendMode::kMultiply;
+    return SkBlendMode::kSrcOver;
+}
+
+} // namespace
+
+struct SkiaDrawer::Impl {
+    std::vector<sk_sp<SkShader>> shaders;
+    MeshCache meshes;
+    std::vector<int> order; // scratch
+    SkPaint paint;
+    SkPaint layerPaint;
+
+    void drawMesh(SkCanvas* canvas, const SkVertices* vertices, int texture, SkPaint& p) {
+        p.setShader(shaders[texture]);
+        // No per-vertex colors, so the vertex blend mode is unused; the shader alone colors the mesh.
+        canvas->drawVertices(vertices, SkBlendMode::kDst, p);
+    }
+};
+
+SkiaDrawer::SkiaDrawer() : _impl(std::make_unique<Impl>()) {
+    _impl->paint.setAntiAlias(true);
+}
+
+SkiaDrawer::~SkiaDrawer() = default;
+
+void SkiaDrawer::setTextures(jsi::Runtime& runtime, const jsi::Value& shaders, const jsi::Value& sizes) {
+    jsi::Array shaderArray = shaders.asObject(runtime).asArray(runtime);
+    jsi::Array sizeArray = sizes.asObject(runtime).asArray(runtime);
+    const size_t count = shaderArray.size(runtime);
+    if (sizeArray.size(runtime) != count * 2) {
+        throw jsi::JSError(runtime, "Live2D: expected a width and height per texture");
+    }
+    _impl->shaders.clear();
+    std::vector<SkISize> textureSizes;
+    for (size_t i = 0; i < count; ++i) {
+        auto shader = unwrap<RNSkia::JsiSkShader>(runtime, shaderArray.getValueAtIndex(runtime, i), "an SkShader");
+        _impl->shaders.push_back(shader->getObject());
+        textureSizes.push_back(SkISize::Make(
+            static_cast<int>(sizeArray.getValueAtIndex(runtime, i * 2).asNumber()),
+            static_cast<int>(sizeArray.getValueAtIndex(runtime, i * 2 + 1).asNumber())));
+    }
+    _impl->meshes.setTextureSizes(std::move(textureSizes));
+}
+
+jsi::Value SkiaDrawer::draw(jsi::Runtime& runtime, const jsi::Value& canvasValue, bool wantStats,
+                            const csmModel* model, const CanvasInfo& info) {
+    if (_impl->shaders.empty()) throw jsi::JSError(runtime, "Live2D: call setTextures before draw");
+    SkCanvas* canvas = unwrap<RNSkia::JsiSkCanvas>(runtime, canvasValue, "an SkCanvas")->getCanvas();
+    Impl& d = *_impl;
+
+    const int count = csmGetDrawableCount(model);
+    d.meshes.resize(count);
+    d.meshes.resetStats();
+    int layers = 0;
+
+    const int* renderOrders = cubism::renderOrders(model);
+    const csmFlags* dynamicFlags = csmGetDrawableDynamicFlags(model);
+    const csmFlags* constantFlags = csmGetDrawableConstantFlags(model);
+    const int* textureIndices = csmGetDrawableTextureIndices(model);
+    const float* opacities = csmGetDrawableOpacities(model);
+    const int* maskCounts = csmGetDrawableMaskCounts(model);
+    const int** masks = csmGetDrawableMasks(model);
+
+    // Draw order: drawable indices sorted by render order.
+    std::vector<int>& order = d.order;
+    order.resize(count);
+    std::iota(order.begin(), order.end(), 0);
+    std::sort(order.begin(), order.end(), [&](int a, int b) { return renderOrders[a] < renderOrders[b]; });
+
+    for (int i : order) {
+        if (!(dynamicFlags[i] & csmIsVisible) || opacities[i] <= 0) continue;
+        const SkVertices* vertices = d.meshes.meshOf(model, i, info);
+        if (!vertices) continue;
+
+        if (maskCounts[i] == 0) {
+            d.paint.setAlphaf(opacities[i]);
+            d.paint.setBlendMode(blendModeOf(constantFlags[i]));
+            d.drawMesh(canvas, vertices, textureIndices[i], d.paint);
+            continue;
+        }
+
+        // Draw into a layer, cut it with the union of the masks, then composite
+        // the layer with the drawable's blend mode.
+        const SkRect& bounds = vertices->bounds();
+        d.layerPaint.setBlendMode(blendModeOf(constantFlags[i]));
+        canvas->saveLayer(&bounds, &d.layerPaint);
+        d.paint.setAlphaf(opacities[i]);
+        d.paint.setBlendMode(SkBlendMode::kSrcOver);
+        d.drawMesh(canvas, vertices, textureIndices[i], d.paint);
+
+        d.layerPaint.setBlendMode((constantFlags[i] & csmIsInvertedMask) ? SkBlendMode::kDstOut : SkBlendMode::kDstIn);
+        canvas->saveLayer(&bounds, &d.layerPaint);
+        d.paint.setAlphaf(1);
+        for (int m = 0; m < maskCounts[i]; ++m) {
+            const int maskIndex = masks[i][m];
+            const SkVertices* maskVertices = d.meshes.meshOf(model, maskIndex, info);
+            if (maskVertices) d.drawMesh(canvas, maskVertices, textureIndices[maskIndex], d.paint);
+        }
+        canvas->restore();
+        canvas->restore();
+        layers += 2;
+    }
+
+    if (!wantStats) return jsi::Value::undefined();
+    jsi::Object stats(runtime);
+    stats.setProperty(runtime, "meshesBuilt", d.meshes.meshesBuilt());
+    stats.setProperty(runtime, "layers", layers);
+    stats.setProperty(runtime, "meshMs", d.meshes.meshMs());
+    return stats;
+}
+
+} // namespace margelo::nitro::live2dskia
+
+#endif // LIVE2D_SKIA

package/cpp/drawing/SkiaDrawer.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#if LIVE2D_SKIA
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+#include "Live2DCubismCore.hpp"
+
+namespace margelo::nitro::live2dskia {
+
+namespace jsi = facebook::jsi;
+
+struct CanvasInfo {
+    float originX;
+    float originY;
+    float pixelsPerUnit;
+};
+
+// Draws a model's drawables onto a react-native-skia canvas in C++, the same
+// way src/rendering/drawer.ts does in JS, without building meshes through JSI.
+// Not thread-safe: HybridLive2DModel serializes calls.
+class SkiaDrawer {
+    public:
+        SkiaDrawer();
+        ~SkiaDrawer();
+
+        // shaders: SkShader[] (one per texture); sizes: [width0, height0, width1, ...].
+        void setTextures(jsi::Runtime& runtime, const jsi::Value& shaders, const jsi::Value& sizes);
+
+        // Draws the model's current state onto a JS SkCanvas. Returns
+        // { meshesBuilt, layers, meshMs } when wantStats, else undefined.
+        jsi::Value draw(jsi::Runtime& runtime, const jsi::Value& canvas, bool wantStats,
+                        const Live2D::Cubism::Core::csmModel* model, const CanvasInfo& info);
+
+    private:
+        struct Impl;
+        std::unique_ptr<Impl> _impl;
+};
+
+} // namespace margelo::nitro::live2dskia
+
+#endif // LIVE2D_SKIA