@airisu-dev/react-native-live2d-skia 0.1.2-nightly.20261025.2b7609a → 0.2.0-rc.1

package/README.md

@@ -162,6 +162,17 @@ const gesture = useLive2DGestures([
 </GestureDetector>
 ```
 
+To animate a model, pass Reanimated shared values as `x`, `y` or `scale` (the gesture hooks take the same). It moves on the UI thread, with no React render per frame:
+
+```tsx
+const x = useSharedValue(0)
+useEffect(() => {
+  x.set(withRepeat(withTiming(80, { duration: 1500 }), -1, true))
+}, [x])
+// …
+<Live2D model={model} x={x} y={0} scale={0.4} />
+```
+
 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
@@ -175,6 +186,10 @@ model.expression('exp_01') // expression; random without a name
 model.resetExpression()
 model.setParameter('ParamAngleX', 30) // held over motions until resetParameter
 model.resetParameter('ParamAngleX')
+model.resetParameters() // release every held parameter
+model.getParameter('ParamAngleX') // current value, motions and physics applied
+model.stopMotion() // stops it where it is
+model.resetPose() // stops it and eases back to the default pose
 model.focus(x, y) // look at a point, easing
 model.resetFocus()
 model.hitTest(x, y) // → ['Head']
@@ -182,6 +197,28 @@ 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.
 
+### Driving the model from a camera or an animation
+
+To drive parameters at a high rate, e.g. from face tracking, keep the JS thread out of it. `useLive2DParameters` holds parameters at the values of a Reanimated shared value, passing them on from the UI thread. Write the shared value from any worklet:
+
+```tsx
+const values = useSharedValue<Record<string, number>>({})
+useLive2DParameters(model, values, { smoothing: 0.08 })
+// in a worklet: values.value = { ParamAngleX: yaw * 30, ParamEyeLOpen: leftEyeOpen }
+```
+
+A camera frame processor (e.g. react-native-vision-camera with ML Kit or `react-native-fast-tflite`) can also call the native model directly, in one locked call per frame:
+
+```ts
+model.native.setParameters(['ParamAngleX', 'ParamEyeLOpen'], [yaw * 30, leftEyeOpen])
+```
+
+- Values are clamped to each parameter's range, and ids the model doesn't have are ignored.
+- Trackers deliver 15-30 values a second and the display shows 60 frames: `smoothing` (a time constant in seconds, `model.setParameterSmoothing(0.08)`) eases held parameters towards their values in between.
+- Typical mapping: head yaw, pitch and roll to `ParamAngleX`, `ParamAngleY` and `ParamAngleZ` (about ±30°, mirrored for a front camera), eye openness to `ParamEyeLOpen` and `ParamEyeROpen`, mouth openness to `ParamMouthOpenY`, smile to `ParamMouthForm`.
+- `useLive2DModel(source, { idleMotion: false })` (or `model.setIdleMotionEnabled(false)` later) stops the random `Idle` motions that start whenever nothing plays, so only your values drive the model. Call `model.resetParameters()` when the face is lost, and the model's own motions take over again.
+- `model.resetPose()` eases what motions moved back to the default pose and leaves held parameters alone, so it can be called mid-motion while tracking runs.
+
 ## API
 
 ### `useLive2DModel(source, options?)`
@@ -199,14 +236,16 @@ Methods can be called from the JS thread while the model animates on its backgro
 | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `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 |
+| `idleMotion` | Whether a random `Idle` motion starts whenever nothing plays, from the first frame. Default `true`; `model.setIdleMotionEnabled` changes it later                                                                                                  |
+| `eyeBlink`   | Whether the eyes blink, for models with eye blink parameters. Default `true`; `model.setEyeBlinkEnabled` changes it later                                                                                                                          |
 
 ### `<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`                                                                                                                         |
+| `x`, `y`              | Top-left position on the canvas: a number, or a Reanimated shared value. Default `0`                                                                                                 |
+| `scale`               | Uniform scale of the model's native canvas size: a number, or a shared value. 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` |
@@ -235,18 +274,32 @@ The gesture is built once; targets are read at touch time, so they can change on
 
 The same for one model: `options` is a target (without `model`) plus `focus`.
 
+### `useLive2DParameters(model, values, options?)`
+
+Holds parameters at the values of a `SharedValue<Record<string, number>>` as it changes, from the UI thread, and releases them on unmount. `options.smoothing` is the easing time constant in seconds (default `0`). `useLive2DParameter(model, id, value)` is the same for one parameter and a `SharedValue<number>`.
+
 ### `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                                                                                                |
+| 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                                                                                                 |
+| `setParameters(values)`                          | `setParameter` for each entry of a `{ id: value }` object, in one locked call                                                                   |
+| `setParameterSmoothing(seconds)`                 | Eases held parameters towards their values; `0` (default) applies them as they are                                                              |
+| `setIdleMotionEnabled(enabled)`                  | Whether a random `Idle` motion starts when nothing plays. Default `true`                                                                        |
+| `setEyeBlinkEnabled(enabled)`                    | Whether the eyes blink, for models with eye blink parameters. Default `true`                                                                    |
+| `resetParameters()` / `getParameter(id)`         | Releases every held parameter / reads a parameter's current value                                                                               |
+| `stopMotion()` / `isMotionPlaying()`             | Stops the playing motion, leaving the model where it was (an `Idle` one starts again if enabled) / whether one plays                            |
+| `resetPose(fadeSeconds?)`                        | Stops the playing motion and eases every parameter and switched pose part back to its default (0.5 s by default, `0` snaps); held ones stay     |
+| `motions`                                        | `Record<group, MotionInfo[]>`: file, duration, loop and fades of each motion, from the model's files                                            |
+| `expressions`                                    | `ExpressionInfo[]`: name, file and the parameters each expression sets                                                                          |
+| `parameters`                                     | `ParameterInfo[]`: id, min, max, default, and the name and group from the model's `cdi3.json` if it has one. `setParameter` clamps to the range |
+| `motionGroups`, `expressionNames`                | The names in `motions` and `expressions`                                                                                                        |
+| `width`, `height`                                | The model's native canvas size                                                                                                                  |
 
 ## Contributing
 

package/cpp/cubism/HeldParameterUpdater.hpp

@@ -1,25 +1,45 @@
 #pragma once
+#include <cmath>
 #include <map>
 #include "CubismModelSettingJson.hpp"
 #include "Motion/ICubismUpdater.hpp"
 
 namespace margelo::nitro::live2dskia {
 
-// Applies setParameter values every update, after look and breath (so they
+// A parameter held at `target` by setParameter(s). `current` is what the model gets: the
+// target, or eased towards it when smoothing is on.
+struct HeldParameter {
+    float target = 0;
+    float current = 0;
+    // Set until the first update after holding: `current` starts from the model's own value.
+    bool fresh = true;
+};
+
+// Applies the held parameters 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) {}
+        // `smoothing` is the time constant in seconds of the easing, 0 for none.
+        HeldParameterUpdater(std::map<Live2D::Cubism::Framework::CubismIdHandle, HeldParameter>& values, const float& smoothing)
+            : ICubismUpdater(Live2D::Cubism::Framework::CubismUpdateOrder_Breath + 50), _values(values), _smoothing(smoothing) {}
 
-        void OnLateUpdate(Live2D::Cubism::Framework::CubismModel* model, Live2D::Cubism::Framework::csmFloat32) override {
-            for (const auto& [id, value] : _values) {
-                model->SetParameterValue(id, value);
+        void OnLateUpdate(Live2D::Cubism::Framework::CubismModel* model, Live2D::Cubism::Framework::csmFloat32 deltaSeconds) override {
+            const float tau = _smoothing;
+            for (auto& [id, held] : _values) {
+                if (tau <= 0) {
+                    held.current = held.target;
+                } else {
+                    if (held.fresh) held.current = model->GetParameterValue(id);
+                    held.current += (held.target - held.current) * (1.0f - std::exp(-deltaSeconds / tau));
+                }
+                held.fresh = false;
+                model->SetParameterValue(id, held.current);
             }
         }
 
     private:
-        const std::map<Live2D::Cubism::Framework::CubismIdHandle, float>& _values;
+        std::map<Live2D::Cubism::Framework::CubismIdHandle, HeldParameter>& _values;
+        const float& _smoothing;
 };
 
 } // namespace margelo::nitro::live2dskia

package/cpp/cubism/Live2DUserModel.cpp

@@ -1,4 +1,5 @@
 #include "Live2DUserModel.hpp"
+#include <algorithm>
 #include <stdexcept>
 #include "CubismDefaultParameterId.hpp"
 #include "CubismHelpers.hpp"
@@ -36,7 +37,7 @@ Live2DUserModel::Live2DUserModel(const uint8_t* moc, size_t mocSize, const std::
 
     if (_eyeBlinkIds.GetSize() > 0) {
         _eyeBlink = CubismEyeBlink::Create(_setting);
-        _updateScheduler.AddUpdatableList(CSM_NEW CubismEyeBlinkUpdater(_motionUpdated, *_eyeBlink));
+        _updateScheduler.AddUpdatableList(CSM_NEW CubismEyeBlinkUpdater(_skipEyeBlink, *_eyeBlink));
     }
 
     _breath = CubismBreath::Create();
@@ -62,7 +63,7 @@ Live2DUserModel::Live2DUserModel(const uint8_t* moc, size_t mocSize, const std::
     _look->SetParameters(look);
     _updateScheduler.AddUpdatableList(CSM_NEW CubismLookUpdater(*_look, *_dragManager));
 
-    _updateScheduler.AddUpdatableList(CSM_NEW HeldParameterUpdater(_heldParameters));
+    _updateScheduler.AddUpdatableList(CSM_NEW HeldParameterUpdater(_heldParameters, _parameterSmoothing));
 
     _updateScheduler.SortUpdatableList();
     _model->SaveParameters();
@@ -82,13 +83,29 @@ Live2DUserModel::~Live2DUserModel() {
 }
 
 void Live2DUserModel::setParameter(const std::string& id, float value) {
-    _heldParameters[idOf(id.c_str())] = value;
+    const CubismIdHandle handle = idOf(id.c_str());
+    const csmInt32 index = _model->GetParameterIndex(handle);
+    if (index < 0) return;
+    const float clamped = std::min(_model->GetParameterMaximumValue(index), std::max(_model->GetParameterMinimumValue(index), value));
+    // Holding again keeps `current`, so a changing target is eased towards, not restarted.
+    _heldParameters[handle].target = clamped;
+}
+
+void Live2DUserModel::setParameters(const std::vector<std::string>& ids, const std::vector<double>& values) {
+    const size_t count = std::min(ids.size(), values.size());
+    for (size_t i = 0; i < count; ++i) {
+        setParameter(ids[i], static_cast<float>(values[i]));
+    }
 }
 
 void Live2DUserModel::clearParameter(const std::string& id) {
     _heldParameters.erase(idOf(id.c_str()));
 }
 
+void Live2DUserModel::clearParameters() {
+    _heldParameters.clear();
+}
+
 void Live2DUserModel::focus(float x, float y) {
     SetDragging(x, y);
 }
@@ -109,8 +126,10 @@ void Live2DUserModel::update(float deltaSeconds) {
     // Same order as the SDK sample's LAppModel::Update.
     _motionUpdated = false;
     _model->LoadParameters();
+    // Before motions, so one started during the fade blends in from the easing pose.
+    if (_poseResetRemaining > 0) easeToDefaultPose(deltaSeconds);
     if (_motionManager->IsFinished()) {
-        startRandomMotion("Idle", PriorityIdle);
+        if (_idleMotionEnabled) startRandomMotion("Idle", PriorityIdle);
     } else {
         _motionUpdated = _motionManager->UpdateMotion(_model, deltaSeconds);
     }
@@ -118,6 +137,7 @@ void Live2DUserModel::update(float deltaSeconds) {
 
     // Eye blink (unless a motion moved the eyes), expression, look, breath,
     // held parameters, physics, pose.
+    _skipEyeBlink = _motionUpdated || !_eyeBlinkEnabled;
     _updateScheduler.OnLateUpdate(_model, deltaSeconds);
     _model->Update();
 }

package/cpp/cubism/Live2DUserModel.hpp

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 #include "CubismModelSettingJson.hpp"
+#include "HeldParameterUpdater.hpp"
 #include "Model/CubismUserModel.hpp"
 
 namespace margelo::nitro::live2dskia {
@@ -28,12 +29,28 @@ class Live2DUserModel : public csm::CubismUserModel {
         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 stopMotion();
+        bool isMotionPlaying();
+        // Stops motions and eases every parameter to its default over `fadeSeconds` (0 snaps).
+        void resetPose(float fadeSeconds);
         void loadExpression(const std::string& name, const std::string& json);
         bool setExpression(const std::string& name);
         bool setRandomExpression();
         void clearExpression();
+        // Clamped to the parameter's range; ids the model doesn't have are ignored.
         void setParameter(const std::string& id, float value);
+        void setParameters(const std::vector<std::string>& ids, const std::vector<double>& values);
         void clearParameter(const std::string& id);
+        void clearParameters();
+        // Time constant in seconds of the easing of held parameters towards their value, 0 for none.
+        float parameterSmoothing() const { return _parameterSmoothing; }
+        void setParameterSmoothing(float seconds) { _parameterSmoothing = seconds < 0 ? 0 : seconds; }
+        // Whether a random Idle motion starts whenever no motion plays.
+        bool idleMotionEnabled() const { return _idleMotionEnabled; }
+        void setIdleMotionEnabled(bool enabled) { _idleMotionEnabled = enabled; }
+        // Whether the eyes blink (models with eye blink parameters only).
+        bool eyeBlinkEnabled() const { return _eyeBlinkEnabled; }
+        void setEyeBlinkEnabled(bool enabled) { _eyeBlinkEnabled = enabled; }
         // -1..1 on each axis, y-up.
         void focus(float x, float y);
         // Hit area names containing the point (model units, y-up).
@@ -49,9 +66,17 @@ class Live2DUserModel : public csm::CubismUserModel {
         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;
+        std::map<csm::CubismIdHandle, HeldParameter> _heldParameters;
+        float _parameterSmoothing = 0;
+        bool _idleMotionEnabled = true;
+        bool _eyeBlinkEnabled = true;
+        // Seconds left of a resetPose fade, 0 when none runs.
+        float _poseResetRemaining = 0;
+        void easeToDefaultPose(float deltaSeconds);
         // Read by the eye blink updater: no blinking while a motion moves the eyes.
         csm::csmBool _motionUpdated = false;
+        // Read by the eye blink updater: set while a motion moves the eyes or blinking is off.
+        csm::csmBool _skipEyeBlink = false;
 };
 
 } // namespace margelo::nitro::live2dskia

package/cpp/cubism/Live2DUserModelAnimation.cpp

@@ -3,6 +3,7 @@
 #include <cstdlib>
 #include <iterator>
 #include <stdexcept>
+#include <vector>
 #include "CubismHelpers.hpp"
 #include "Motion/CubismMotion.hpp"
 #include "Motion/CubismPhysicsUpdater.hpp"
@@ -68,6 +69,51 @@ bool Live2DUserModel::startRandomMotion(const std::string& group, Priority prior
     return startMotion(group, std::rand() % count, priority);
 }
 
+void Live2DUserModel::stopMotion() {
+    _motionManager->StopAllMotions();
+}
+
+bool Live2DUserModel::isMotionPlaying() {
+    return !_motionManager->IsFinished();
+}
+
+void Live2DUserModel::resetPose(float fadeSeconds) {
+    _motionManager->StopAllMotions();
+    // Motions also switch pose parts (Hiyori's raised arm is PartArmB) through per-part values
+    // that aren't model parameters. Reset puts back the first part of each group; restoring the
+    // opacities it set lets the pose fade to that part instead of popping.
+    if (_pose) {
+        const csmInt32 partCount = _model->GetPartCount();
+        std::vector<csmFloat32> opacities(static_cast<size_t>(partCount));
+        for (csmInt32 i = 0; i < partCount; ++i) opacities[i] = _model->GetPartOpacity(i);
+        _pose->Reset(_model);
+        if (fadeSeconds > 0) {
+            for (csmInt32 i = 0; i < partCount; ++i) _model->SetPartOpacity(i, opacities[i]);
+        }
+    }
+    // update() starts each frame from the saved parameters, so a stopped motion alone
+    // leaves the model frozen in its last pose: move those towards the defaults instead.
+    if (fadeSeconds > 0) {
+        _poseResetRemaining = fadeSeconds;
+        return;
+    }
+    _poseResetRemaining = 0;
+    for (csmInt32 i = 0; i < _model->GetParameterCount(); ++i) {
+        _model->SetParameterValue(i, _model->GetParameterDefaultValue(i));
+    }
+    _model->SaveParameters();
+}
+
+void Live2DUserModel::easeToDefaultPose(float deltaSeconds) {
+    // Linear in time: each frame covers its share of what is left, so it lands at the end.
+    const float t = deltaSeconds >= _poseResetRemaining ? 1.0f : deltaSeconds / _poseResetRemaining;
+    for (csmInt32 i = 0; i < _model->GetParameterCount(); ++i) {
+        const float value = _model->GetParameterValue(i);
+        _model->SetParameterValue(i, value + (_model->GetParameterDefaultValue(i) - value) * t);
+    }
+    _poseResetRemaining = t >= 1.0f ? 0 : _poseResetRemaining - deltaSeconds;
+}
+
 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());

package/cpp/hybrid/HybridLive2DModel.cpp

@@ -3,6 +3,7 @@
 #include <numeric>
 #include "CubismSetup.hpp"
 #include "CubismCompat.hpp"
+#include "CubismHelpers.hpp"
 
 namespace margelo::nitro::live2dskia {
 
@@ -106,6 +107,21 @@ bool HybridLive2DModel::startMotion(const std::string& group, std::optional<doub
     return _userModel->startMotion(group, static_cast<int>(*index), toPriority(priority));
 }
 
+void HybridLive2DModel::stopMotion() {
+    std::lock_guard lock(_mutex);
+    _userModel->stopMotion();
+}
+
+bool HybridLive2DModel::isMotionPlaying() {
+    std::lock_guard lock(_mutex);
+    return _userModel->isMotionPlaying();
+}
+
+void HybridLive2DModel::resetPose(std::optional<double> fadeSeconds) {
+    std::lock_guard lock(_mutex);
+    _userModel->resetPose(static_cast<float>(fadeSeconds.value_or(0.5)));
+}
+
 void HybridLive2DModel::loadExpression(const std::string& name, const std::string& json) {
     std::lock_guard lock(_mutex);
     _userModel->loadExpression(name, json);
@@ -131,6 +147,69 @@ void HybridLive2DModel::clearParameter(const std::string& id) {
     _userModel->clearParameter(id);
 }
 
+std::vector<ParameterData> HybridLive2DModel::getParameters() {
+    std::lock_guard lock(_mutex);
+    auto* model = _userModel->model();
+    const int count = model->GetParameterCount();
+    std::vector<ParameterData> result;
+    result.reserve(count);
+    for (int i = 0; i < count; ++i) {
+        result.emplace_back(std::string(model->GetParameterId(i)->GetString().GetRawString()),
+                            model->GetParameterMinimumValue(i),
+                            model->GetParameterMaximumValue(i),
+                            model->GetParameterDefaultValue(i),
+                            model->GetParameterValue(i));
+    }
+    return result;
+}
+
+double HybridLive2DModel::getParameterValue(const std::string& id) {
+    std::lock_guard lock(_mutex);
+    auto* model = _userModel->model();
+    const int index = model->GetParameterIndex(idOf(id.c_str()));
+    return index < 0 ? 0.0 : model->GetParameterValue(index);
+}
+
+void HybridLive2DModel::setParameters(const std::vector<std::string>& ids, const std::vector<double>& values) {
+    std::lock_guard lock(_mutex);
+    _userModel->setParameters(ids, values);
+}
+
+void HybridLive2DModel::clearParameters() {
+    std::lock_guard lock(_mutex);
+    _userModel->clearParameters();
+}
+
+double HybridLive2DModel::getParameterSmoothing() {
+    std::lock_guard lock(_mutex);
+    return _userModel->parameterSmoothing();
+}
+
+void HybridLive2DModel::setParameterSmoothing(double seconds) {
+    std::lock_guard lock(_mutex);
+    _userModel->setParameterSmoothing(static_cast<float>(seconds));
+}
+
+bool HybridLive2DModel::getIdleMotionEnabled() {
+    std::lock_guard lock(_mutex);
+    return _userModel->idleMotionEnabled();
+}
+
+void HybridLive2DModel::setIdleMotionEnabled(bool enabled) {
+    std::lock_guard lock(_mutex);
+    _userModel->setIdleMotionEnabled(enabled);
+}
+
+bool HybridLive2DModel::getEyeBlinkEnabled() {
+    std::lock_guard lock(_mutex);
+    return _userModel->eyeBlinkEnabled();
+}
+
+void HybridLive2DModel::setEyeBlinkEnabled(bool enabled) {
+    std::lock_guard lock(_mutex);
+    _userModel->setEyeBlinkEnabled(enabled);
+}
+
 void HybridLive2DModel::focus(double x, double y) {
     std::lock_guard lock(_mutex);
     _userModel->focus(static_cast<float>(std::clamp(x, -1.0, 1.0)), static_cast<float>(std::clamp(y, -1.0, 1.0)));

package/cpp/hybrid/HybridLive2DModel.hpp

@@ -26,11 +26,24 @@ class HybridLive2DModel : public HybridLive2DModelSpec {
         void loadPose(const std::string& json) override;
         void loadMotion(const std::string& group, double index, const std::string& json) override;
         bool startMotion(const std::string& group, std::optional<double> index, std::optional<MotionPriority> priority) override;
+        void stopMotion() override;
+        bool isMotionPlaying() override;
+        void resetPose(std::optional<double> fadeSeconds) override;
         void loadExpression(const std::string& name, const std::string& json) override;
         bool setExpression(const std::optional<std::string>& name) override;
         void clearExpression() override;
         void setParameter(const std::string& id, double value) override;
         void clearParameter(const std::string& id) override;
+        void setParameters(const std::vector<std::string>& ids, const std::vector<double>& values) override;
+        void clearParameters() override;
+        double getParameterSmoothing() override;
+        void setParameterSmoothing(double seconds) override;
+        bool getIdleMotionEnabled() override;
+        void setIdleMotionEnabled(bool enabled) override;
+        bool getEyeBlinkEnabled() override;
+        void setEyeBlinkEnabled(bool enabled) override;
+        std::vector<ParameterData> getParameters() override;
+        double getParameterValue(const std::string& id) override;
         void focus(double x, double y) override;
         std::vector<std::string> hitTest(double x, double y) override;
         void update(double deltaSeconds) override;

package/nitrogen/generated/shared/c++/HybridLive2DModelSpec.cpp

@@ -20,16 +20,29 @@ namespace margelo::nitro::live2dskia {
       prototype.registerHybridGetter("originY", &HybridLive2DModelSpec::getOriginY);
       prototype.registerHybridGetter("pixelsPerUnit", &HybridLive2DModelSpec::getPixelsPerUnit);
       prototype.registerHybridGetter("drawableCount", &HybridLive2DModelSpec::getDrawableCount);
+      prototype.registerHybridGetter("parameterSmoothing", &HybridLive2DModelSpec::getParameterSmoothing);
+      prototype.registerHybridSetter("parameterSmoothing", &HybridLive2DModelSpec::setParameterSmoothing);
+      prototype.registerHybridGetter("idleMotionEnabled", &HybridLive2DModelSpec::getIdleMotionEnabled);
+      prototype.registerHybridSetter("idleMotionEnabled", &HybridLive2DModelSpec::setIdleMotionEnabled);
+      prototype.registerHybridGetter("eyeBlinkEnabled", &HybridLive2DModelSpec::getEyeBlinkEnabled);
+      prototype.registerHybridSetter("eyeBlinkEnabled", &HybridLive2DModelSpec::setEyeBlinkEnabled);
       prototype.registerHybridMethod("getDrawables", &HybridLive2DModelSpec::getDrawables);
       prototype.registerHybridMethod("loadPhysics", &HybridLive2DModelSpec::loadPhysics);
       prototype.registerHybridMethod("loadPose", &HybridLive2DModelSpec::loadPose);
       prototype.registerHybridMethod("loadMotion", &HybridLive2DModelSpec::loadMotion);
       prototype.registerHybridMethod("startMotion", &HybridLive2DModelSpec::startMotion);
+      prototype.registerHybridMethod("stopMotion", &HybridLive2DModelSpec::stopMotion);
+      prototype.registerHybridMethod("isMotionPlaying", &HybridLive2DModelSpec::isMotionPlaying);
+      prototype.registerHybridMethod("resetPose", &HybridLive2DModelSpec::resetPose);
       prototype.registerHybridMethod("loadExpression", &HybridLive2DModelSpec::loadExpression);
       prototype.registerHybridMethod("setExpression", &HybridLive2DModelSpec::setExpression);
       prototype.registerHybridMethod("clearExpression", &HybridLive2DModelSpec::clearExpression);
       prototype.registerHybridMethod("setParameter", &HybridLive2DModelSpec::setParameter);
       prototype.registerHybridMethod("clearParameter", &HybridLive2DModelSpec::clearParameter);
+      prototype.registerHybridMethod("setParameters", &HybridLive2DModelSpec::setParameters);
+      prototype.registerHybridMethod("clearParameters", &HybridLive2DModelSpec::clearParameters);
+      prototype.registerHybridMethod("getParameters", &HybridLive2DModelSpec::getParameters);
+      prototype.registerHybridMethod("getParameterValue", &HybridLive2DModelSpec::getParameterValue);
       prototype.registerHybridMethod("focus", &HybridLive2DModelSpec::focus);
       prototype.registerHybridMethod("hitTest", &HybridLive2DModelSpec::hitTest);
       prototype.registerHybridMethod("update", &HybridLive2DModelSpec::update);

package/nitrogen/generated/shared/c++/HybridLive2DModelSpec.hpp

@@ -17,12 +17,15 @@
 namespace margelo::nitro::live2dskia { struct DrawableData; }
 // Forward declaration of `MotionPriority` to properly resolve imports.
 namespace margelo::nitro::live2dskia { enum class MotionPriority; }
+// Forward declaration of `ParameterData` to properly resolve imports.
+namespace margelo::nitro::live2dskia { struct ParameterData; }
 
 #include "DrawableData.hpp"
 #include <vector>
 #include <string>
 #include <optional>
 #include "MotionPriority.hpp"
+#include "ParameterData.hpp"
 
 namespace margelo::nitro::live2dskia {
 
@@ -57,6 +60,12 @@ namespace margelo::nitro::live2dskia {
       virtual double getOriginY() = 0;
       virtual double getPixelsPerUnit() = 0;
       virtual double getDrawableCount() = 0;
+      virtual double getParameterSmoothing() = 0;
+      virtual void setParameterSmoothing(double parameterSmoothing) = 0;
+      virtual bool getIdleMotionEnabled() = 0;
+      virtual void setIdleMotionEnabled(bool idleMotionEnabled) = 0;
+      virtual bool getEyeBlinkEnabled() = 0;
+      virtual void setEyeBlinkEnabled(bool eyeBlinkEnabled) = 0;
 
     public:
       // Methods
@@ -65,11 +74,18 @@ namespace margelo::nitro::live2dskia {
       virtual void loadPose(const std::string& json) = 0;
       virtual void loadMotion(const std::string& group, double index, const std::string& json) = 0;
       virtual bool startMotion(const std::string& group, std::optional<double> index, std::optional<MotionPriority> priority) = 0;
+      virtual void stopMotion() = 0;
+      virtual bool isMotionPlaying() = 0;
+      virtual void resetPose(std::optional<double> fadeSeconds) = 0;
       virtual void loadExpression(const std::string& name, const std::string& json) = 0;
       virtual bool setExpression(const std::optional<std::string>& name) = 0;
       virtual void clearExpression() = 0;
       virtual void setParameter(const std::string& id, double value) = 0;
       virtual void clearParameter(const std::string& id) = 0;
+      virtual void setParameters(const std::vector<std::string>& ids, const std::vector<double>& values) = 0;
+      virtual void clearParameters() = 0;
+      virtual std::vector<ParameterData> getParameters() = 0;
+      virtual double getParameterValue(const std::string& id) = 0;
       virtual void focus(double x, double y) = 0;
       virtual std::vector<std::string> hitTest(double x, double y) = 0;
       virtual void update(double deltaSeconds) = 0;