Tutorial Charakteranimation: Unterschied zwischen den Versionen

Version vom 4. Januar 2014, 18:08 Uhr

Hinweis: Dieser Artikel wird gerade Offline bearbeitet! Bitte haben Sie etwas Geduld und nehmen Sie keine Änderungen vor, bis der Artikel hochgeladen wurde. (weitere Artikel)

Dieses Tutorial befindet sich mitten in der Erstellung. Wie bist du überhaupt hierher gekommen? ;-)

Einleitung

In diesem Tutorial möchte ich euch beibringen, wie man starre Meshes lebendig erscheinen lässt, indem man sie bewegt. Und zwar wollen wir sie nicht nur verschieben und drehen, sondern richtig animieren, also verformen. Ein sicherer Umgang mit Matrizen, VBOs und Shadern wird hier vorausgesetzt.

Das Skelett

Es gibt verschiedene Ansätze, ein Mesh durch Animation zu verformen. Meistens möchte man in Computerspielen Menschen oder Tiere (oder etwas, das ihnen ähnelt) animieren, die sich nur sehr eingeschränkt verformen können - nämlich so, wie es ihr Skelett zulässt. Daher kommt meistens Skelett-basierte Animation zum Einsatz. Sich bewegene Maschinen oder Roboter sind meistens noch beschränkter in ihrer Bewegegungsfreiheit, sodass sich deren Animationen ebenfalls mittels eines Skeletts realisieren lässt. Die Idee ist einfach: Man speichert für einen Charakter nur, wie sich das Skelett bei einer Animation bewegt. Das Skelett besteht aus deutlich weniger Teilen, als das Mesh (die Haut) Vertices hat. Die Auswirkungen auf die Vertices selbst werden erst während des Renderns in Echtzeit berechnet. Durch dieses Verfahren wird eine Menge Speicherplatz, aber auch Aufwand beim Erstellen und Bearbeiten von Animationen gespart.

Woraus besteht also ein Skelett? Aus Gelenken (Joints) und Knochen (Bones). In der Grafikprogrammierung hat es sich bewährt, Skelette hierarchisch aufzubauen. Das heißt, es gibt genau ein Supergelenk, das keinem anderen Gelenk untergeordnet ist. Dieses Gelenk wird auch Wurzel genannt, denn in der Informatik würde man sagen, das Skelett ist ein Baum. Das Wurzelgelenk besitzt untergeordnete Gelenke (Kinder), die mit jeweils einem Knochen mit ihm verbunden sind. Dreht man nun das Wurzelgelenk, so drehen sich alle untergeordneten Knochen und Gelenke (und deren Kinder) mit. Dies entspricht der Realität: Wenn du deinen Arm hebst, d.h. dein Schultergelenk drehst, bewegen sich das Ellenbogen- und Handgelenk, sowie alle Knochen der Hand entsprechend mit.

Das für die Animation benötigte Skelett muss bei weitem nicht so detailliert sein, wie das reale menschliche Skelett. Mit 64 Joints (inklusive Finger) kann man bereits gute Ergebnisse erzielen. Das hier abgebildete Skelett hat 65 Joints, wobei man sich die Spitzen der Finger und Füße noch sparen könnte. (Sie dienen hier nur dazu, die äußersten Knochen zu visualisieren.)

Mathematisch gesehen können wir ein Gelenk durch eine Rotation, eine Position, um die rotiert wird, und die Menge aller Untergelenke beschreiben. Dadurch werden gleichzeitig auch alle Knochen beschrieben, da diese nichts weiter als die Verbindung zwischen einem Eltern- und Kind-Joint sind. Die Rotation lässt sich auf viele Arten beschreiben, z.B. durch eine 3x3-Matrix oder ein Quaternion (wobei letzteres aufgrund der guten Interpolierbarkeit zu empfehlen ist). Die Position beschreibt man am einfachsten durch einen Translationsvektor relativ zum Elternknoten. Die Rotation wird in der Regel auch erstmal relativ zum Elternknoten angegeben.

Die absolute Rotation eines Gelenks erhält man ganz einfach, indem man die absolute Rotation des Elternknotens mit der eigenen relativen multipliziert. Die absolute Rotation des Elternknotens muss man natürlich vorher erst einmal berechnen (es sei denn, der Elternknoten ist die Wurzel). Ihr seht schon - das ist ein rekursiver Vorgang:

Joint.AbsRot = ParentJoint.AbsRot * Joint.RelRot

Die absolute Position lässt sich ebenfalls rekursiv berechnen. Man multipliziert die absolute Rotationsmatrix des Elternknotens mit der relativen Position und addiert anschließend die absolute Position des Elternknotens:

Joint.AbsPos = Joint.AbsRot * Joint.RelPos  +  Parent.AbsPos

Die Animation

Die Animation besteht nun aus einer Folge von KeyFrames. Ein KeyFrame beschreibt den Zustand des Skeletts zu einer bestimmten Zeit. Für jeden KeyFrame werden also gespeichert:

• Die Zeit
• Die Rotation jedes Joints (relativ zum Eltern-Joint)
• Die Position jedes Joints (ebenfalls relativ zum Eltern-Joint)

Die KeyFrames werden nach der Zeit sortiert in einem Array gespeichert. Zwischen den KeyFrames kann man interpolieren und somit auch Zustände des Skeletts zwischen zwei KeyFrames berechnen. Das macht man sich bei der Animation zu nutze.

Man benötigt also eine Zeitvariable time (vom Typ float), die man beim Starten der Animation auf 0 setzt. In jedem Frame (hier ist nicht KeyFrame gemeint, sondern Frame wie in Framerate) erhöht man time um die im letzten Frame vergangene Zeit. Nun sucht man den KeyFrame mit der größten Zeit, die noch kleiner ist als time. Bei der Suche sollte man ausnutzen, dass man die KeyFrames nach der Zeit sortiert hat. Es wäre unnötig langsam, jeden einzelnen KeyFrame der Liste abzuklappern. Besser wäre

• sich das Suchergebnis vom letzten Frame zu merken und die Suche ab dort zu starten oder
• eine binäre Suche oder
• eine proportionale Suche.

Die Suche liefert uns den Index k des gesuchten KeyFrames, so dass gilt:

KeyFrames[k].time < time <= KeyFrames[k+1].time

f = (time - KeyFrames[k].time) / (KeyFrames[k+1].time - KeyFrames[k].time)

Skinning

Schön und gut, wir wissen jetzt, was ein Skelett ist und wie man es dreht. Doch was ändert das am Mesh? Schließlich wollen wir in der Endanwendung ja nichts mehr vom Skelett sehen. Offensichtlich benötigen wir eine Möglichkeit, die Vertices des Meshs mit dem Skelett zu verbinden. Das ist nicht schwierig: Wir ordnen jedem Vertex die Nummer (einen Integer) des Gelenks zu, das ihn beeinflusst. Das ist nicht der Weisheit letzter Schluss, aber sehr einfach und genau das Richtige, wenn man überhaupt erstmal ein Ergebnis sehen will.

Transformation der Positionen

Wir wissen nun von einem Vertex, welche Position er in der Standardpose (bei Menschen i.d.R. T-Pose) hat und von welchem Gelenk er beeinflusst wird. Um zu verstehen, was mit den Vertices bei der Animation passiert, betrachten wir beispielhaft den hier in grün markierten Vertex:

Er ist dem Ellenbogen-Gelenk (roter Kreis links neben ihm) des linken (aus unserer Sicht rechten) Arms zugeordnet.

Als erstes berechnen wir den Verbindungsvektor vom Joint in T-Pose zum Vertex:

Diff = VPos - TPoseJoint.AbsPos

Diesen Verbindungsvektor rotieren wir nun entsprechend der aktuellen Ausrichtung des Joints. Das heißt, wir wenden die absolute Rotationsmatrix bzw. das Quaternion des Joints an:

Rotated = Joint.AbsRot * Diff

Den erhaltenen Rotationsvektor addieren wir schließlich auf die absolute Position des Joints im animierten Skelett;

Result = Joint.AbsPos + Rotated

Die fertige Position entspricht dem, was wir hier sehen:

Diese drei Schritte solltest du unbedingt nachvollzogen und verstanden haben, bevor du dich an die Implementierung machst. Man beachte v.a. den Unterschied zwischen TPoseJoint (enthält Position und Rotation in Standardpose, also unbewegt wie im ersten Bild) und Joint (das Ergebnis der KeyFrame-Interpolation, zweites Bild).

Transformation von Normalen

Ein Vertex besteht nicht nur aus einer Position. Normalen und andere Vektoren, die lediglich eine Richtung und keine Position enthalten, brauchen natürlich nicht wie Positionsvektoren transliert werden. Auf sie wird nur die Rotation (Schritt 2) angewandt.

Transformation von Texturkoordinaten

"Hö? Wieso müssen Texturkoordinaten transformiert werden?" Wenn du dich das beim Lesen der Überschrift dieses Abschnitts gefragt hast, liegst du genau richtig. Texturkoordinaten sind nicht von der Animation betroffen. Dieser Abschnitt ist nur ein Test, ob du bis hierher alles verstanden hast. ;-)
Hier wäre eine gute Stelle, das bisher gelernte zu vertiefen, indem du dich an einer eigener Implementation versuchst.

Skinning für Fortgeschrittene

Im letzten Abschnitt habe ich geschrieben, dass wir jedem Vertex ein Gelenk zuordnen. Wenn es gut aussehen soll, reicht eins allein jedoch nicht aus. Denn was soll man beispielsweise mit einem Vertex machen, der auf der Haut des Handgelenks eines Menschen liegt? Gehört er zum Hand- oder doch zum Unterarmknochen? Die Antwort lautet: beides. Seine Position wird sowohl von der Drehung des Ellenbogens, als auch von der Drehung des Handgelenks beeinflusst. Das heißt, wir müssen jedem Vertex mindestens zwei Gelenke zuordnen. In der Praxis nimmt man oft sogar vier. So werden wir auch im Folgenden verfahren.

Doch nun, da wir festgestellt haben, dass oft kein Knochen alleinigen Einfluss auf einen Vertex hat, müssen wir für jeden der 4 Joints auch noch den Anteil an Einfluss speichern. Dafür hat sich der Begriff BoneWeight eingebürgert. Ich benutze lieber die Bezeichnung JointWeight, da wir die Transformationen, die wir hiermit gewichten, nicht pro Bone, sondern pro Joint speichern. Das JointWeight hat einen Wert zwischen 0 und 1 und i.d.R. ist es so, dass die Summe aller JointWeights eines Vertex 1 ergibt. Somit kann man ein wenig Speicherplatz sparen, da man das letzte JointWeight jederzeit berechnen kann:

Leztes JointWeight = 1 - (Summe aller anderen JointWeights)

Gewichtete Transformation

Das Schwierigste an der skeletalen Animation ist wohl die korrekte Gewichtung der Transformationen, die in den einzelnen Joints gespeichert ist. Im letzten Abschnitt haben wir gesehen, dass die Transformation eines Vertex (bzw. seiner Position) aus drei Schritten besteht. Erst eine Translation, dann eine Rotation und zum Schluss noch eine Translation. Wer sich ein bisschen mit Matrizen auskennt (und das hatte ich am Anfang des Tutorials vorausgesetzt ;-) ), der weiß, dass man alle drei Transformationen in nur eine Matrix stecken kann.

Matrix-Interpolation

Da scheint es doch naheliegend zu sein, für jeden Joint eine solche Matrix zu bauen. Da jeder Vertex von 4 Joints beeinflusst wird, warum gewichtet man dann nicht einfach die Matrizen?

finalMatrix = Matrix[JointID[0]] * JointWeight[0]
            + Matrix[JointID[1]] * JointWeight[1]
            + Matrix[JointID[2]] * JointWeight[2]
            + Matrix[JointID[3]] * JointWeight[3];
finalPos = finalMatrix * VPos;

Leider bringt die Matrix-Interpolation nicht das gewünschte Ergebnis.

Lineare Vertex-Interpolation

Was dagegen schon halbwegs brauchbar ist, ist ein ähnlicher Ansatz. Man baut wieder die Matrizen wie beim Ansatz eben. Zum Gewichten der Transformation mittelt man nun aber nicht die Matrizen, sondern die mit ihnen transformierten Vektoren:

pos0 = Matrix[JointID[0]] * VPos;
pos1 = Matrix[JointID[1]] * VPos;
pos2 = Matrix[JointID[2]] * VPos;
pos3 = Matrix[JointID[3]] * VPos;
finalPos = pos0 * JointWeight[0]
         + pos1 * JointWeight[1]
         + pos2 * JointWeight[2]
         + pos3 * JointWeight[3];

Das dieser Ansatz auch nicht optimal ist, kann man gut an dieser Grafik sehen: [Bild]

Quaternion + Translationsvektor

ToDo

Dual Quaternions

ToDo

Verformung

Nun, da wir jedem Vertex eine Liste von Joints und deren Gewichte zugeordnet haben, können wir endlich ausrechnen, wie genau sich die Position durch die Joints ändert. Dazu gibt es verschiedene Ansätze, die jeweils ihre eigenen Vor- und Nachteile haben und sich vor allem in der Art der Interpolation zwischen mehreren Joints unterscheiden. Rotationsmatrix + Positionsvektor Dies ist der intuitivste Ansatz, da er sich praktisch direkt aus der oben stehenden Definition des Skeletts ergibt. Man nimmt sich die Position des Vertexes, den man transformieren möchte. Diese nennen wir im Folgenden VPos. Diesen Vektor möchten wir nun um das erste Gelenk rotieren. Dazu ziehen wir die absolute Position (JAbsPos) des Gelenks ab, multiplizieren das Ergebnis mit der Rotationsmatrix (JRotMatrix) des Gelenks und addieren anschließend die zuvor abgezogene absolute Gelenk-Position wieder drauf: [Code]res[0] = JRotMatrix[0] * (VPos - JAbsPos[0]) + JAbsPos[0];[/Code] Das wäre alles, wenn nur ein einziger Joint den Vertex beeinflussen würde. Da wir jedoch mehrere Joints pro Vertex haben, müssen wir diese Berechnung für jeden von ihnen wiederholen. Am Ende haben wir vier Vektoren res, die noch - unter Berücksichtigung des BoneWeights - gemittelt werden wollen: [Code]res[0] = res[0]*boneWeight[0] + res[1]*boneWeight[1] + res[2]*boneWeight[2] + res[3]*boneWeight[3];[/Code] So einfach geht das. Allerdings hat diese billige Methode einen ganz gravierenden Nachteil. [Bild] Dadurch, dass nicht die Rotationen selbst, sondern erst die fertig berechneten Positionen (linear) interpoliert werden, ergeben sich visuelle Artefakte in Form seltsamer Knicks. Das führt bei Menschen z.B. dazu, dass der Arm bei bestimmten Drehungen "abgeschnürt" wird. Man könnte nun auf die Idee kommen, diese 2 Translationen und die eine Rotation in eine 4x4-Matrix zu stecken, und dann die Matrizen zu interpolieren, statt die resultierenden Vektoren. Das bringt allerdings keine Besserung. Quaternion + Positionsvektor Dual Quaternions Dual Quaternions sind die mathematisch anspruchsvollste Methode, das Interpolationsproblem zu lösen. Dafür ist das Ergebnis qualitativ am höchsten und noch dazu sehr schnell und speicherplatzsparend - kurz: State-of-the-art.

ToDo

Bilder
Erklärungen zur Qualität der Interpolationsmethoden
Abschnitt Verformung
Vertexshader