After Effects Expressions – Mathe in Expressions

Hallo Leute,

willkommen zu einem weiteren Expression Tutorial von mir. Es gibt hier nur eine Überschrift dafür: Mathe!

Vorerst möchte ich aber bemerken, dass dies ein fortgeschrittenen Tutorial ist und für Anfänger nur schwer zu verfolgen. Vorausetzungen:

+ Expressions in After Effects

+ Abstrakte Motion Graphics: Part 1 – Expressions

+ Mathe Schulkenntnisse bis 10. oder 11. Klasse (wäre gut)

Mit Mathe und Expression, also dieser Kombi, können wir die verschiedensten Dinge in After Effects realisieren.

Wir kümmern uns hier um physikalische Simulationen, die immer ein sehr gefragtes Thema sind:

Physikalische Simulationen sind bei den meisten der interessantesten und herausfordernden Animationen in After Effects beteiligt. Auch wenn es um komplexe 3D Animationen geht. Leider versteckt sich dann hinter manch eine komplizierte Formel oder ein anderer mathematische Ausdruck, auf den man vielleicht am Anfang nicht sofort kommt. Auch beim Verständnis mancher dieser Gleichungen, Graphen usw. gibt es bei ein paar Leuten Probleme. Damit diese hier nicht auftreten, bzw. keine Chance haben, beginnen wir mal mit ein paar Grundlagen die man in der Schule in spätestens der 9. Klasse gemacht haben sollte:

Trigonometrische Funktionen.

Sagt euch nichts? Dann vielleicht: Winkelfunktionen.

Auch nicht? Vielleicht dann der Begriff: Sinus-Graph, Kosinus-Graph und Tangens-Graph?

Oh manno, man… also wer damit gar nichts mehr anfangen kann, der sollte sich dringendst mal wieder damit beschäftigen, wenn man irgendwelche Physikalischen Simulationen in AE erstellen möchte^^.

Ein Sinus bietet eine schöne regelmäßige Wellenform, die für sehr viele Animationen nützlich sein kann.

Wir empfehlen:
3D-Projekte in After Effects

Die Grundform des Sinusgraphen ist =  f(x) –> sin(x). In Expressions sieht diese jedoch ein klein wenig anders aus:

Math.sin(time);

Warum denn das? Also „time“ ist der einzige Wert, der ständig steigt, genauso wie bei einer Funktion das „x“. Und „Math.sin“ ist die Beschreibung vom Sinus in Javascript, worauf ja, wie ihr wissen solltet, After Effects Expressions basieren.  Wendet diese Expression doch einfach mal auf einen Wert eurer Wahl an, der nur EIN Argument hat (Position zum Beispiel hat 2 oder 3^^). Ich hab hier mal einfach die Drehung genommen. Klickt ihr bei der Expression jetzt dieses kleine Graph-Symbol an und bei eurer Zeitleiste das größere seht ihr euren Sinus:

Den Kosinus seht ihr auf die selbe Weise nur mit:

Math.cos(time);

als Expression.  Gucken wir uns jetzt Sinus und Kosinus an, dann sehen wir, dass die nicht nur irgendwie verschoben sind sondern genau um eine viertel „Periodenlänge“. So ergibt sich, dass der Sinus bei 0 und der Kosinus bei vollem Wert (in diesem Fall 1) startet. Beides kann in verschiedenen Situationen sehr nützlich sein.

Nun aber mal ein praktisches Beispiel bei dieser ganzen Theorie hier^^:

Auf- und Ab-Bewegung quer über den Bildschirm.

Wir wollen das ganz gleich professionell angehen und erstellen uns schon einmal Expression-Regler, mit Funktionen die wir ändern können wollen. Es werden nur Schieberegler, aber auch die muss man erst einmal erstellen. Geht unter „Einstellungen für Expressions > Einstellungen für Schieberegler“ und fügt diesen der Ebene, die ihr bewegen wollt, (ich habe in diesem Fall den PSD-Schmetterling benutzt, ihr könnt aber alles benutzen. Einen Ball einen Stern usw.) hinzu. Diesen neuen Schieberegler nennen wir mit „Enter“: Geschwindigkeit (pps). Das „pps“ steht für PixelPerSecond. Denn das ist die Geschwindigkeitseinheit hier. Dann dupliziert den Schieberegler ganz einfach mit STRG + D und nennt diesen: Stärke (px). Das wird die Stärke der Schwankungen in Pixeln. Dupliziert auch den noch einmal und nennt diesen wiederum: Häufigkeit (wps). Das is die Häufigkeit der „WavesPerSecond“ also Wellen pro Sekunde. Stellt die Regler auf Werte von ca. 100 Geschwindigkeit, ca. 20 Stärke und ca. 5 bei Häufigkeit. Soweit so gut, nur tun diese Expression-Regler noch nichts^^

Also jetzt geht’s ans Eingemachte: Die EXPRESSION

Wir müssen erst einmal sehen, was bei dieser Bewegung auf welcher Achse passiert.

Also hier sieht man, dass die Sinusfunktion nur auf der Y-Achse angewendet ist und x sich einfach nur ständig vorwärts bewegt.

Na dann mal ans Werk:

Erst einmal müssen wir die ganzen Controller einbinden:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");

Jede Zeile mit „//“ davor ist übrigens ein Kommentar. Ich benutze diese um die Übersicht in manchen Expressions zu behalten, sie sind aber nicht zwingend notwendig. Aber jetzt weiter.

Auf der X-Achse soll die Position mit der Zeit steigen. Wir wärs dann einfach mit „x = time“.

Aber wir wollen die Geschwindigkeit festlegen können also so:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = time * geschw;

Ok. Damit wäre die X-Bewegung geschafft. Weiter geht’s mit Y. Es soll ein Sinus-Kurve entstehen also hier einmal das Grundgerüst dazu: „Math.sin(time“.

Jetzt wollen wir aber hier noch die Stärke und Häufigkeit festlegen können. Das machen wir folgendermaßen:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");

x = time * geschw;
y = Math.sin(time * häufig) * stärke;

Jetzt befindet sich die Bewegung aber noch am oberen Rand des Videos. Deswegen müssen wir die Hälfte der Kompositionshöhe hinzufügen um wieder bei der Mitte zu landen:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");

x = time * geschw;
y = Math.sin(time * häufig) * stärke + thisComp.height/2;

So jetzt müssen die Variablen x und y nur noch den Argumenten des Positionsparameters zugeordnet werden und fertig is unserer Expression. Deswegen hier einmal die Zusammenfassung:

Damit haben wir schon unsere erste auf Mathe basierende Expression geschaffen! Jetzt geht’s gleich weiter:

Nächstes Beispiel: Auf- und Ab-Bewegung quer über den Bildschirm, die von links nach rechts stärker wird.

Also müssen wir bei der Y-Bewegung noch ein wenig was ändern. Es soll mit der Zeit stärker werden. Wie hatten wir die Stärke eingebaut? Mit Multiplikation. Wie kann mal also zeitliche Stärkung einbauen? Mit der aktuellen Zeit multiplizieren!

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");

x = time * geschw;
y = time * Math.sin(time * häufig) * stärke + thisComp.height/2;

[x,y]

Soweit so gut, jetzt das ganze ein wenig schwieriger:

Auf- und Ab-Bewegung quer über den Bildschirm, die von links nach rechts schwächer wird.

Wir müssen den Zeitwert „time“ jetzt irgendwie umkehren.

Dies kann man mit der Funktion „linear()“ machen. Linear() ist zum konvertieren von einem Zahlenbereich einer Variablen da. Hier mal kurz die linear()-Funktion erklärt:

Unsere linear()-Funktion sieht folgendermaßen aus:

linear(time,0,6,6,0);

Ich nehme also den Wert von „time“. Davon nehme ich den Zahlenbereich von 0 bis 6 Sekunden. Warum 6 Sekunden? Solange ist meine momentane Komposition. Also müsst ihr diesen Wert euren Bedürfnissen nach anpassen. Danach kommen Ziel-Star – und Endwert. Diese sind genau umgekehrt zu dem eigentlichen Start- und Endwert. Somit wird der Wert von „time“ umgekehrt. Diesen umgekehrten Wert ersetzen wir jetzt also das ursprüngliche „time“:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");

x = time * geschw;
y = linear(time,0,6,6,0) * Math.sin(time * häufig) * stärke + thisComp.height/2;

[x,y]

So bekommen wir folgendes Ergebnis:

Nächstes Beispiel:

Hüpfende Bewegung quer über den Bildschirm.

Wie wir ganz am Anfang richtigerweise festgestellt haben hat der Sinus Wellen die zwischen -1 und 1 schwanken. Das heißt es folgt immer ein positiver auf einen negativen Bereich. Was würde denn passieren wenn wir die negativen Bereiche auch noch positiv machen würden? Eine hüpfartige Bewegung würde entstehen. Genau das was wir suchen.

Jetzt brauchen wir nur noch eine Lösung die negativen Bereiche positiv zu machen und die positiven auch positiv zu lassen. Dazu gibt in der Mathematik Methode um Zahlen zu verändern, die folgendermaßen heißt „Absoluter Betrag“. Der Absoluter Betrag einer Zahl ist immer positiv. Er beschreibt den Abstand der Zahl zur Null. In der Mathematik würde man schreiben:

|-50| = 50

In Javascript folgendermaßen:

Math.abs(-50) = 50;

Also beschreibt „Math.abs()“ den Absoluten Betrag einer Zahl. Wenden wir das ganze doch mal auf unseren Sinus auf der Y-Achse an:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = time * geschw - 52;
y = Math.abs(Math.sin(time * häufig)) * stärke  + thisComp.height/2;
[x,y]

So sieht das ganze aus:

Naja, also die Wellen sind schon einmal den Bögen gewichen, aber sind jetzt etwa nicht alle Werte positiv sondern negativ geworden? Nein! After Effects hat ein eigenartiges Koordinatensystem was die Y-Achse angeht:

Also müssen wir unsere Hügel noch ins Negative umkehren. Dazu kann man zwar einfach *-1 sagen, oder, da wir eh die Stärke damit malnehmen, machen wir einfach die Stärke negativ:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = time * geschw - 52;
y = Math.abs(Math.sin(time * häufig)) * -stärke  + thisComp.height/2;
[x,y]

Mit dieser Expression hätten wir dann auch unseren „Hüpflook“.
Jetzt gehen wir noch einen Schritt weiter, was physikalische Simulationen angeht: Exponentielle Funktionen und Graphen.

Ein Exponent (ich hoffe eigentlich, dass ihr das wisst, denn das ist Allgemeinwissen^^) ist das was oben bei einer Potenz steht, das heißt z.B. bei: „a²“  wäre es „2“.

Aus diesen Potenzen kann man auch Funktionen  und Graphen draus machen.

In Javascript kann man exponentielle Funktionen folgendermaßen erstellen:

Math.exp(time); (erstellt eine Funktion die f(x) –>x² entspricht. Also nur quadrieren)

oder

Math.pow(time,3); (erstellt eine Funktion die f(x) –>x³ entspricht. Also alle möglichen Exponenten)

Exponentielle Funktionen sind hier in folgender Richtung wichtig: In Wirklichkeit gibt es einen Abfall z.B. des Hüpfens. Dieser Abfall ist nicht wie vorhin in einem Beispiel von uns dargestellt linear, sondern exponentiell. Deswegen die ganzen exponentiellen Sachen hier zwischendurch. Möchte man also realistische Physikalische Simulationen erstellen kommt man weder um Exponentielle- also auch um Trigonometrische Funktionen herum. Da wir beides nun gemacht haben können wir ja zu richtigen Physikalischen Simulationen übergehen.

Ein gutes Beispiel zum Einstieg in Physikalische Simulationen ist ein Pendel. Erstellt einfach ins in einer Formebene (nur CS3) oder mit Masken. Das einzige was wichtig dabei ist, ist, dass ihr den Ankerpunkt der Ebene ganz oben an den Ursprung des Pendels setzt. Diesen verschiebt ihr mit dem „Ausschnitt-Werkzeug“, welches sich direkt Links von dem Masken-Werkzeug befeindet.

Spielt jetzt einmal mit der Drehung der Ebene und ihr seht wie das Pendel schwingt.

Wie wir das Pendel automatisch zum Schwingen bringen dürfte im Groben klar sein, oder? Sinus natürlich^^

Math.sin(time*3)*50

Hiermit wird bewirkt, dass das Pendel 3 Mal die Sekunde um 50° schwingt.

So und jetzt mal ein Pendel das ausschwingt. Natürlich nicht linear sondern exponentiell. Da bei einer exponentiellen Funktion die Werte steigen und wir die Geschwindigkeit mit der Zeit reduzieren wollen, teilen wir einfach die eigentliche Bewegung durch die exponentielle Funktion.

Math.sin(time*3)*50 / Math.exp(time)

Jetzt geht mir das aber zu schnell mit dem Auspendeln. Einmal logisch nachdenken. Wollen wir größere Schwankungen zu einer Zeit, muss die Zahl durch die geteilt wird größer oder kleiner werden?

Kleiner natürlich. Teilen wir dir Zeit vor der Verarbeitung zum Beispiel durch 4:

Math.sin(time*3)*50/Math.exp(time/4)

Somit hätten wir unser Pendel, das sich langsam aber sicher auspendelt.

Nachdem wir nun gelernt haben, wie etwas sich auspendeln lässt, wie sieht es vielleicht aus, wenn wir etwas Springen lassen, und das exponentiell kleiner werden lassen…

Also beim Springen und Hüpfen hatten wir oben folgende Expression:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = time * geschw - 52;
y = Math.abs(Math.sin(time * häufig)) * stärke  + thisComp.height/2;
[x,y]

Denkt daran die Schieberegler zu kopieren oder neu zu erstellen. Meine Werte sind „Geschwindigkeit = 100; Stärke = 70; Häufigkeit = 4“. Um das ganze nun aushüpfen zu lassen müssen wir es also wie oben durch die potenzierte Zeit teilen:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = value[0];
y = -(Math.abs(Math.cos(time * häufig)) * stärke) / Math.exp(time/4) + thisComp.height/2;
[x,y]

Wie er sicherlich bemerkt hab, habe ich hier einmal die X-Angabe und den eigentlichen X-Wert ersetzt um da volle Kontrolle zu haben ich setze einfach mal 2 Keyframes von der einen zur anderen Seite des Bildschirms. Außerdem habe ich noch eine Kleinigkeit geändert. Ich habe das „Math.sin()“ durch ein „Math.cos()“ ersetzt. Warum? Wie weiter oben schon einmal erklärt fängt der Kosinus mit dem vollen Wert an, geht dann aber genauso weiter wie der Sinus. Da das nun eine Art „auf den Boden fallen lass“-Animation werden soll, habe ich die gewählt, denn dann fängt die Bewegung oben und nicht bei 0 an.

Jetzt passiert beim Aufprall aber noch etwas anderes. Das Objekt wird beim Aufprall gestaucht und beim Hochspringen gestreckt. Das ist nun die nächste Herausforderung der wir uns widmen werden. Fangen wir erst einmal an mit einem einfachen Strecken und Stauchen des Schmetterlings in etwas so:

Ich habe diese Expression hier verwendet:

//CONTROL
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
größe = stärke*Math.sin(häufig*time)/Math.exp(time);
value + [größe,größe]

Eigentlich dürfte das Ganze nicht arg zu schwer zu verstehen sein.  Jetzt wollen wir aber, dass nicht X und Y gleichzeitig größer und kleiner werden, sondern genau umgekehrt. Wird X kleiner so wird Y in dem Moment größer. Wir Y größer so wird X kleiner. Wie kann man diese Zeitversetzung hinbekommen? Es wird einfach für beide die selbe Skalierung festgelegt, nur bei Y muss das ganze eine halbe Periodenlänge später passieren, denn:

Hier sieht man einmal den normalen Graphen und dann einen zweiten versetzt um „?“ (gesprochen Pi). Wenn ich das noch alles erklären würde mit ? usw. dann säßen wir morgen noch hier^^. Grundsätzlich gilt: Sinus und Kosinus haben eine Periodenlänge von „2 * ?“. Versetzt man nun einen Sinus um ? handelt er immer Endgegengesetzt zu seinem Ausgansbild (siehe Flashvideo über diesem Absatz). So kriegen wir dann auch unserer Skalierungs-Expression zusammen:

//CONTROL
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = value[0] + stärke*Math.sin(häufig*time)/Math.exp(time);
y = value[1] + stärke*Math.sin(häufig*time + Math.PI)/Math.exp(time);
[x,y]

Und hier das Video:

Kombinieren wir nun die Positionsexpression (minimale Änderung) mit der Skalierungsexpression, dann bekommen wir folgendes Ergebnis:

Die minimale Änderung liegt hier:

//CONTROL
geschw = effect("Geschwindigkeit (pps)")("Schieberegler");
stärke = effect("Stärke (px)")("Schieberegler");
häufig = effect("Häufigkeit (wps)")("Schieberegler");
x = value[0];
y = -(Math.abs(Math.cos(time * häufig / 1.5)) * stärke) / Math.exp(time/4) + thisComp.height/2;
[x,y]

Ich teile die Zeit noch durch 1.5 um die Positionsbewegung zur Skalierung zu synchronisieren.

Das wars jetzt aber mit den Grundlagen. Probiert rum experimentiert!

Mit nur ein paar Handgriffen mehr kann man mit diesen Grundlagen leicht solche Animationen erstellen:

Ich habe hier lediglich für Position und Skalierung verschiedene Schieberegler benutzt und mit den Werten rumgespielt. Tut dies auch mal und ihr werdet staunen, welche Macht hinter diesen kleinen Expressions steckt!

Bis dahin,

Happy Aftereffecting!

PhSn

Wir empfehlen:
Animation in After Effects

Unsere Empfehlung für dich

Animation in After Effects

Animation in After Effects

Es gibt Animationen und es gibt schöne Animationen. Bei dem einen sehen wir bewegte Elemente, bei dem anderen bewegende Momente. Lerne in diesem 8-stündigen Training, wie Animation in After Effects funktioniert und was eine gute Animation ausmacht.

  • Hocheffektiv: Direkt lernen am Praxisprojekt
  • Disney Rules vorgestellt - die Regeln guter Animation verstehen
  • Animationswerkzeuge in AE und Tipps & Tricks zum Workflow
  • Zum optimalen Verständnis inkl. aller Projektdateien

Dieses Training animiert zu schöneren Animationen. Lass uns was zusammen bewegen!

Zum Training