\[ \newcommand{\Ul}{\mathcal{U\ell}} \]

Linear Blending Skinning (LBS) formula

$$ \begin{equation*} \bar{\mathbf{p_i}} = \sum_{j=1}^{n} \ \ w_{ij} \ T_j \ \mathbf{p_i} \end{equation*} $$

• $n$ number of bones
• $w_{ij}$ scalar weight at the i$^{\text{th}}$ vertex associated to the j$^{\text{th}}$ bone
• $T_j$ the 4x4 matrix, the global transformation of the j$^{\text{th}}$ bone from its rest pose.
• $\mathbf{p_i}$ mesh's vertex in rest pose
• $\bar{\mathbf{p_i}}$ the vertex after deformation.

Vec3 linear_blending_skinning(
        const std::vector< std::map<int, float> >& skinning_weights,
        const std::vector<Mat4x4>& skinning_transfos,
        const std::vector<Point3>& in_vertex,
        const std::vector<Vec3>& in_normal,
        std::vector<Point3>& out_vertex,
        std::vector<Vec3>& out_normal)
{
    for(int i = 0; i < skinning_weights.size(); ++i) // For each vertex
    {
        Mat4x4 blend_matrix = Mat4x4::null();
        std::map<int, float> bones = skinning_weights[i];
        for( std::pair<int, float> pair : bones) { // For each bone 
            blend_matrix += skinning_transfos[ pair.first ] * pair.second;
        }
        out_normal[i] = blend_matrix.get_mat3x3().inverse().transpose() * in_normal[i];
        out_vertex[i] = blend_matrix * in_vertex[i];
    }
}

Computing $T_j$ (skinning transformation)

$$ \begin{equation*} T_j = W_j \ (B_j)^{-1} \end{equation*} $$

• $W_j $ joint's world matrix in its current animated position.
• $B_j $ joint's bind matrix in world coordinates, bind matrix is saved at rest position (a.k.a T-pose) of the skeleton. In short, it is the joint's current orientation when binding the mesh to the skeleton.

The global bind pose $ B_j $ is computed by multiplying the chain of local bind matrices. The global animated pose $W_j$ is computed by multiplying the chain of local bind matrices interleaved with input user transformations:

$$ \begin{equation*} \begin{split} W_j &= L_{\text{root}} \ \ \Ul_{\text{root}} \ \cdots \ L_{p(j)} \ \ \Ul_{p(j)} \ \ L_j \ \ \Ul_j \\ W_j &= W_{p(j)} \ \ L_j \ \ \Ul_j \\ B_j &= L_{\text{root}} \ \cdots \ L_{p(j)} \ \ L_j \\ B_j &= B_{p(j)} \ \ L_j \\ \end{split} \end{equation*} $$

• $ p(j) $ parent index of the $j^\text{th}$ joint
• $ L_j $ local transformation (according to the parent joint) of the joint in rest pose.
• $ \Ul_j $ local transformation defined by the user.

Procedure to compute the global skinning transformation $T_j$ by specifying a local transformation at each joint:

void compute_skinning_transformations(Mat4x4* tr) {
    rec_skinning_transfo(tr, g_skel.root(), Mat4x4::identity() );
}

void rec_skinning_transfo(Mat4x4* transfos, int id, const Mat4x4& parent)
{
    // W_j = W_p(j) * L_j * Ul_j
    Mat4x4 world_pos = parent * g_skel.bind_local(id) * g_user_local[id]; 
    // T_j = W_j (B_j)^-1
    transfos[id] = world_pos * g_skel.bind(id).inverse(); 
    for(unsigned i = 0; i < g_skel.sons( id ).size(); i++)
        rec_skinning_transfo(transfos, g_skel.sons( id )[i], world_pos);
}

If you don't have access to the local transformation of the joint $ \Ul_j $ you can compute $T_j$ given the current world position of the joint:

for(int i = 0; i < bones.size(); ++i) {
    Mat4x4 tr = bone_world_transfo(i) * bind[i].inverse(); // T_j = W_j (B_j)^-1
    skinning_transfo[i] = tr;
}

Computing $L_j$ (bind local matrix)

If only the world bind pose $ B_j $ is known you can find back the local bind pose $ L_j $ with:

$$ \begin{equation*} L_j= (B_{p(j)})^{-1} \ B_j \end{equation*} $$

Computing $W_j$ (joint world matrix)

Given a joint in rest pose $ B_j $ you can find back its animated position just apply the current skinning transformation $ T_j$:

$$ \begin{equation*} W_j = T_j \ . \ B_j \end{equation*} $$

Computing $ \Ul_j $ (user local transformation)

You can extract the user local transformation $ \Ul_j $ from the joints world matrix $ W $:

$$ \begin{equation*} \begin{split} W_j & = W_j \\ W_{p(j)} L_j \Ul_j & = W_j \\ L_j \Ul_j & = (W_{p(j)})^{-1} W_j \\ \Ul_j & = (L_j)^{-1} (W_{p(j)})^{-1} W_j \\ \Ul_j & = (W_{p(j)} L_j)^{-1} W_j \\ \end{split} \end{equation*} $$

Set $ \Ul_j $ (user local transformation)

Say we seek to update the local user transformation $\Ul_j$. We could reset it to a new value $\Ul'_j$ or apply an incremental transformation $\Ul'_j = Incr_j \ \ \Ul_j $.

But what if we only have access to $ U_j $, an incremental user transformation in world space? With $ U_j $ we can directly transform an animated joint $ W_j $ to its new position $ W'_j $:

$$ \begin{equation*} \begin{split} W'_j & = U_j \ W_j \\ (L_{\text{root}} \ \ \Ul_{\text{root}} \ \cdots \ L_{p(j)} \ \ \Ul_{p(j)} \ \ L_j \ \ \Ul'_j) & = U_j \ W_j \\ (W_{p(j)} \ \ L_j \ \ \Ul'_j) & = U_j \ W_j \\ \end{split} \end{equation*} $$

Since we seek the new local user transformation $ \Ul'_j $ lets isolate it:

$$ \begin{equation*} \begin{split} (W_{p(j)} \ \ L_j \ \ \Ul'_j) & = U_j \ \ W_j\\ ( L_j \ \ \Ul'_j) & = (W_{p(j)})^{-1} \ \ U_j \ \ W_j \\ \Ul'_j & = (L_j)^{-1} \ \ (W_{p(j)})^{-1} \ \ U_j \ \ W_j \end{split} \end{equation*} $$

Reference

Vertex skinning with GLSL
Smooth skinning tutorial
LBS with Quaternions

Donate