2D-Skelettanimationstransformationen

Ich habe eine Weile versucht, ein 2D-Skelettanimationssystem zu erstellen, und ich glaube, dass ich kurz vor dem Abschluss stehe. Derzeit habe ich folgende Datenstrukturen:

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->xund Bone->ysind die Koordinaten des Endpunktes des Knochens. Der Startpunkt ist gegeben durch (bone->parent->x, bone->parent->y)oder (0, 0). Jede Entität im Spiel hat eine Meshund Mesh->verticeswird als Begrenzungsbereich für die Entität verwendet. Mesh->tex_coordssind Texturkoordinaten. In der Aktualisierungsfunktion der Entität wird die Position der Entität Boneverwendet, um die Koordinaten der Entität zu ändern Vertices, die an sie gebunden sind. Derzeit habe ich:

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;
    }
}

Ich glaube, ich habe alles, was ich brauche. Ich weiß nur nicht, wie ich die Transformationen auf die endgültigen Netzkoordinaten anwenden soll. Welche Transformationen brauche ich hier? Oder ist mein Ansatz einfach völlig falsch?

Ich glaube, Sie würden hier versuchen, Transformationsmatrizen zu verwenden, obwohl ich denke, dass Sie Ihre Aktualisierungsfunktion näher erläutern müssen, um dies zu berücksichtigen. Fragen Sie sich, welche Transformationen Sie benötigen - Übersetzung, 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];

Ich finde es manchmal hilfreich, etwas in einfachem Englisch niederzulegen. Das obige für zB:

Führen Sie für jeden Knochen eine (Transformation) multipliziert mit den Gewichten des Knochens durch.

Ich würde mehr in setzen

• Drehen oder übersetzen wir diesen Knochen?
• Beschränkt der Elternteil diese
  Bewegung?

Matrizen sind dafür praktisch, da sie aus einer solchen Struktur herausarbeiten können, indem Sie die Einschränkung aus den Informationen des Elternknochens herausarbeiten und auf den Kinderknochen anwenden können.

• Führen Sie die Transformation basierend auf vorherigen Fragen durch

Dies mag ein völlig falscher Weg sein, aber sicherlich ein Denkanstoß.