Transformations d'animation squelettique 2D

J'essaie de construire un système d'animation squelettique 2D depuis un certain temps, et je pense que je suis presque sur le point de terminer. Actuellement, j'ai les structures de données suivantes:

struct Bone {
    Bone *parent;
    int child_count;
    Bone **children;
    double x, y;
};

struct Vertex {
    double x, y;
    int bone_count;
    Bone **bones;
    double *weights;
};

struct Mesh {
    int vertex_count;
    Vertex **vertices;
    Vertex **tex_coords;
}

Bone->xet Bone->ysont les coordonnées du point final de l'os. Le point de départ est donné par (bone->parent->x, bone->parent->y)ou (0, 0). Chaque entité du jeu possède un Mesh, et Mesh->verticesest utilisée comme zone de délimitation pour l'entité. Mesh->tex_coordssont des coordonnées de texture. Dans la fonction de mise à jour de l'entité, la position de la Boneest utilisée pour modifier les coordonnées des Verticesqui lui sont liées. Actuellement, ce que j'ai, c'est:

void Mesh_update(Mesh *mesh) {
    int i, j;
    double sx, sy;

    for (i = 0; i < vertex_count; i++) {
        if (mesh->vertices[i]->bone_count == 0) {
            continue;
        }

        sx, sy = 0;
        for (j = 0; j < mesh->vertices[i]->bone_count; j++) {
            sx += (/* ??? */) * mesh->vertices[i]->weights[j];
            sy += (/* ??? */) * mesh->vertices[i]->weights[j];
        }

        mesh->vertices[i]->x = sx;
        mesh->vertices[i]->y = sy;
    }
}

Je pense avoir tout ce dont j'ai besoin, je ne sais pas comment appliquer les transformations aux coordonnées finales du maillage. De quelles transformations ai-je besoin ici? Ou mon approche est-elle complètement fausse?

Je pense que vous chercherez à utiliser des matrices de transformation ici, bien que je pense que vous devez développer votre fonction de mise à jour afin de vous y adapter. Demandez-vous quelles transformations vous avez besoin - traduction, rotation?

        sx, sy = 0;
    for (j = 0; j < mesh->vertices[i]->bone_count; j++) {
        sx += (/* ??? */) * mesh->vertices[i]->weights[j];
        sy += (/* ??? */) * mesh->vertices[i]->weights[j];

Je trouve parfois que mettre quelque chose en anglais simple aide. Ce qui précède, par exemple:

Pour chaque os, effectuez une (transformation) multipliée par les poids de l'os.

Je mettrais plus dans

• Sommes-nous en train de tourner ou de translater cet os?
• Le parent contraint-il ce
  mouvement?

Les matrices sont pratiques pour cela car elles peuvent fonctionner à partir d'une structure comme celle-ci en ce sens que vous pouvez déterminer la contrainte à partir des informations de l'os parent et l'appliquer à l'os enfant.

• Effectuer une transformation basée sur les questions précédentes

Cela peut être une façon complètement erronée, mais certainement matière à réflexion.