# Dynamic Skinning

> Dynamic Skinning adds real-time, art-directable cartoon secondary motion (damped oscillations and drag) on top of standard skinning such as Linear Blend Skinning (LBS), without any physical simulation. It uses the skeleton and the skinning weights of an existing rig. Article: "Dynamic Skinning: Kinematics-Driven Cartoon Effects for Articulated Characters", Damien Rohmer, Karim Salem, Niranjan Kalyanasundaram, Victor Zordan, IEEE Transactions on Visualization and Computer Graphics (TVCG), vol. 32, no. 3, pp. 2684-2694, 2026, DOI 10.1109/TVCG.2026.3653317. Code under the MIT license, interactive web demo and Blender add-on.

This site also hosts the previous work of the same line, Velocity Skinning (Eurographics 2021).

## Method in short

- Oscillation kernel: kappa(t) = A exp(-t/tau) sin(2 pi f t). f: frequency (how fast the skin wobbles, in Hz), tau: damping (how long the oscillation lasts, in s), A: amplitude (how much it bends).
- Measure: the angular velocity Omega_j of each joint j is sampled every 1/60 s and kept in a short history H_j.
- Filter: F_j = D Omega_j + sum_k kappa(k dt) (H_j(t - k dt) - H_j(t - (k+1) dt)). The first term is the drag D (a lag proportional to the current speed; alone, it corresponds to Velocity Skinning, and vanishes when the joint stops). The second term turns every change of speed (start, stop, change of direction) into a damped wobble; the wobbles add up and keep going after the joint stops.
- Bend: each vertex p_i is rotated around the position q_j of each joint, with axis F_j and angle theta = -gamma_i |F_j x (p_i - q_j)|, against the motion and growing with the distance to the joint. The offsets are summed with hierarchical weights beta_ij = sum of the skinning weights of j and of all its descendants (turning the shoulder bends the whole arm). gamma_i is a paintable per-vertex bend weight.
- The offsets are added after standard skinning: p_i = p_i^LBS + d_i. Closed form per vertex, on the CPU or in a GPU vertex shader.
- Extensions: flexible deformation origins (localized effects), painted weights restricting the effect to soft parts.
- Separate deformer in the same article: delayed linear blend skinning (dLBS). The rotation of each joint reaches a vertex with a delay equal to their distance along the skeleton divided by a speed c, so that the motion propagates from the root to the extremities like a wave. dLBS replaces LBS, and the oscillations can be applied on top of it.

## Main pages

- [Project page](https://velocityskinning.com/): overview, comparison videos (standard skinning, drag only, dynamic skinning), method, algorithm, code, Blender add-on, article
- [Interactive web demo](https://velocityskinning.com/demo/): the complete C++ application compiled to WebAssembly (WebGL 2). Characters: Cylinder, Giraffe, Clown, Spot, Snail, Dragon, Cthulhu, Train. Click a joint and drag it; tune f, tau, A, D live; optional delay (dLBS)
- [Velocity Skinning page](https://velocityskinning.com/velocity/): previous work (Eurographics 2021), with its two web demos

## Article

- [Author's version (PDF)](https://velocityskinning.com/assets/dynamic/Dynamic_Skinning_TVCG2026_author_version.pdf)
- [DOI 10.1109/TVCG.2026.3653317](https://doi.org/10.1109/TVCG.2026.3653317)
- [Supplementary material (PDF)](https://velocityskinning.com/assets/dynamic/Dynamic_Skinning_supplementary.pdf)
- [Supplementary video (MP4, 4 min)](https://velocityskinning.com/assets/dynamic/videos/dynamic_skinning_video.mp4)

BibTeX:

```
@article{rohmer2026dynamic,
  author  = {Rohmer, Damien and Salem, Karim and Kalyanasundaram, Niranjan and Zordan, Victor},
  title   = {Dynamic Skinning: Kinematics-Driven Cartoon Effects for Articulated Characters},
  journal = {IEEE Transactions on Visualization and Computer Graphics},
  volume  = {32},
  number  = {3},
  pages   = {2684--2694},
  year    = {2026},
  doi     = {10.1109/TVCG.2026.3653317}
}
```

## Code

- [GitHub repository](https://github.com/drohmer/dynamic_skinning): C++17, OpenGL 3.3, CMake and GLFW; macOS, Linux, Windows, and web (Emscripten). MIT license
- `code/app_complete/`: complete application (all the characters, CPU or GPU skinning, joint picking, dLBS, web version)
- `code/app_minimal/`: simplest use of the method, on the CPU
- `code/dynamic_skinning_source/`: the method itself (about 550 lines of C++ for the oscillations)
- `code/shaders/skinning/`: GPU version as a vertex shader
- Build: `cd code && cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j && build/complete`

Integration in an existing skinning pipeline (from `code/app_minimal/scene.cpp`):

```cpp
dynamic_skinning_initialize(ds_state, model, mesh);   // once: weights beta_ij, empty history
model.set_skeleton_from_animation(anim, t);           // each frame: pose
model.skinning_lbs(mesh);                             // standard skinning
ds_parameters.frequency   = 2 * Pi * f;               // kappa(t) = A exp(-t/tau) sin(2 pi f t)
ds_parameters.attenuation = 1 / tau;
ds_parameters.amplitude   = A;
ds_parameters.drag        = D;
dynamic_skinning_apply(ds_state, ds_parameters, model, mesh, t);  // adds the offsets d_i
```

## Blender add-on

- [dynamic_skinning-0.1.0.zip](https://velocityskinning.com/assets/dynamic/blender/dynamic_skinning-0.1.0.zip): prototype extension for Blender 5.0 or later (MIT license). Install from Edit > Preferences > Get Extensions > Install from Disk; enable it in Object properties > Dynamic Skinning on a mesh with an Armature modifier. Oscillations and drag (no dLBS, no flexible origins), real-time playback
- Examples: [spot.blend](https://velocityskinning.com/assets/dynamic/blender/spot.blend), [cylinder.blend](https://velocityskinning.com/assets/dynamic/blender/cylinder.blend)

## Line of work and disambiguation

- 2021: Velocity Skinning for Real-time Stylized Skeletal Animation. Rohmer, Tarini, Kalyanasundaram, Moshfeghifar, Cani, Zordan. Eurographics 2021, Computer Graphics Forum 40(2), pp. 549-561, DOI 10.1111/cgf.142654 (https://velocityskinning.com/velocity/)
- 2022: Acceleration Skinning: Kinematics-Driven Cartoon Effects for Articulated Characters. Kalyanasundaram, Rohmer, Zordan. Graphics Interface 2022
- 2025: Dynamic Skinning: Kinematics-Driven Cartoon Effects for Articulated Characters. Salem, Rohmer, Kalyanasundaram, Zordan. SIGGRAPH 2025 Posters
- 2026: Dynamic Skinning: Kinematics-Driven Cartoon Effects for Articulated Characters. Rohmer, Salem, Kalyanasundaram, Zordan. IEEE TVCG 32(3) (this project)
- Not the same work as: Larboulette, Cani, Arnaldi, "Dynamic Skinning: Adding Real-time Dynamic Effects to an Existing Character Animation", Spring Conference on Computer Graphics 2005, an earlier and different method with a similar name.

## Optional

- [Velocity Skinning article (PDF, Eurographics 2021)](https://velocityskinning.com/velocity/Velocity_Skinning_EG2021.pdf), DOI 10.1111/cgf.142654, Honorable Mention of the Günter Enderle Award
- Velocity Skinning code: [C++](https://github.com/drohmer/velocity_skinning_cpp), [GPU](https://github.com/drohmer/velocity_skinning_gpu), [Web](https://github.com/drohmer/velocity_skinning_web)
- Contact: damien.rohmer [at] polytechnique.edu