Willkommen bei

Random Post Refresh
Mitglieder-Login
Noch kein Mitglied?

Zur Registrierung

Passwort vergessen!
Translation
Okt 20

« 1 2 »

Max von Tettenborn beschreibt in seinem Tutorial sehr anschaulisch wie man Wellen entlang eines animierten Objektes in XSI mit ICE generiert…  

Ich versuche das Tutorial so zu schreiben, dass auch ICE-Neulinge einigermaßen damit klar kommen und hoffe, die Profis können es verschmerzen, wenn ich manchmal vermeindlich simple Details ausführlich beschreibe. Übrigens führt jedes Bild per Klick auf eine große Version, was vor allem bei den ICE-Trees nützlich ist.

Aber erstmal ein Video vom finalen Effekt:


1.Setup






Für unsere Wellen brauchen wir natürlich die Wasseroberfläche die erstmal nur ein Grid ist. (In meinem Fall mit einer Seitenlänge von 20 und 50×50 Unterteilungen) Außerdem brauchen wir ein Schiff oder irgendein Verdrängungskörper, bei mir ist das nur eine Sphere mit Radius 1. Am besten wird der Verdrängungskörper per Path Constrain in einer interessanten Bewegung durch das Grid animiert. Wenn wir das alles haben, machen wir uns ans ICE. Wir selektieren das Grid, öffnen den ICE-Tree und erstellen ein Simulated ICE-Tree. Am besten holen wir uns auch gleich die Simulate Particles-Node und verbinden sie, denn ich jedenfalls vergesse die gerne und wundere mich dann, warum nix passiert.

2. Verdrängung





Mit dem Aufbau unseres ICE-Trees starten wir ganz simpel. Als erstes muss unser Schiff in der Lage sein, das Wasser zu verdrängen. Dazu gibt es zwar schon einen mitgelieferten Compound namens Footprints, aber da der auch nur aus ein paar Nodes besteht, basteln wir uns das schnell selbst, dann verstehen wir auch, was eigentlich genau passiert.

Prinzipiell soll jeder Vertex unseres Grids vom Schiff nach unten gedrückt werden, also entlang der Y-Achse. Da wir dafür die Position des Vertex ändern müssen brauchen wir also eine SetData-Node, in die wir self.pointposition eintragen. Deren Execute-Port verbinden wir mit dem ICE-Tree. In den gelben Input können wir jetzt eine beliebige Position stecken und der Vertex wird diese Position annehmen.

Als nächstes müssen wir berechnen, welche Position der Vertex denn annehmen soll. Diese wird durch die Geometrie des Schiffes definiert, denn der Vertex soll so weit nach unten (also in Richtung -Y) verschoben werden, bis er genau auf dem Schiffsrumpf liegt. Dafür benutzen wir die Raycast-Node. Diese Node schießt einen Strahl von Position in die Richtung Direction und prüft, wo dieser Strahl auf Geometry trifft. Diese Position wird dann als Location weitergegeben. In unserem Fall ziehen wir uns unser Schiff per Drag&Drop in den ICE-Tree und stöpseln es in den Geometry-Port, denn die Position, die wir brauchen soll ja auf dem Schiffsrumpf liegen. Die Position, von der aus geschossen wird, ist die Position des aktuell berechneten Vertex, also holen wir uns eine GetData-Node, tragen wieder self.pointposition ein und stöpseln diese in den Position-Port der Raycast-Node. Als Direction tragen wir 0, -1,0 ein, was dafür sorgt, dass der Strahl entlang der Y-Achse geschossen wird. Damit er wirklich nur nach unten geschossen wird, stellen wir noch sicher, dass die Proximity-Method auf Semi-Line steht. Andernfalls würde der Strahl in beide Richtungen geschossen werden (Line) oder nur so lang sein, wie in Direction angegeben, also eine Einheit (Segment).

Die Location, die wir von der Raycast-Node bekommen, muss jetzt noch in eine Position, also einen 3D-Vektor umgewandelt werden. Dazu holen wir uns eine weitere GetData-Node, tragen dort pointposition ein und ziehen den Location-Port der Raycast-Node in den Source-Port der neuen GetData-Node. Deren Value-Output ist die gesuchte Position und kommt in den Input unserer SetData-Node.

Wenn wir die Simulation nun abspielen, sollte das Schiff bereits eine Spur in dem Grid hinterlassen.


3. Pendelbewegung






Im zweiten Schritt sorgen wir dafür, dass sich die Vertices, die von Schiff nach unten gedrückt wurden, wieder zurück nach oben bewegen, sobald das Schiff vorbei gefahren ist. Genauer gesagt, sollen sie in eine Pendelbewegung versetzt werden, so dass sie auf ihrem Weg nach oben über das ziel hinaus schießen, anschließend wieder nach unten beschleunigt werden usw.

Das bedeutet, dass eine Kraft auf die Vertices wirken muss, die sie ständig in Richtung ihrer Anfangsposition beschleunigt. Wir holen uns also eine weitere SetData-Node und tragen dieses Mal self.force ein. Der Vektor, den wir nun in den Input stöpseln können, definiert die Richtung und Stärke der Kraft, die wirken soll. Diese Kraft wird dann von der Simulate Particles-Node in eine Geschwindigkeitsänderung umgerechnet und diese wiederum in eine Positionsänderung.

Wie vorher die Position muss natürlich auch die Kraft für jeden Vertex berechnet werden. Diese Vektor soll immer von der aktuellen Position des Vertex zu seiner Anfangsposition zeigen. Da die Anfangsposition aber nirgends gespeichert ist, müssen wir ein bisschen tricksen.

Wir wissen, dass alle Vertices zu Anfang der Simulation Y=0 gilt, sie also flach in der Ebene liegen, und dass diese Y-Position das einzige ist, was durch die Verdrängung verändert wird. Die X- und Z-Positionen bleiben also unverändert. Für die Anfangsposition jedes Vertex gilt also X(anfang)=X(aktuell), Y(anfang)=0, Z(anfang)=Z(aktuell). Mit Hilfe von zwei Conversion-Nodes können wir diese Position in ICE errechnen. Dazu holen wir uns zuerst die aktuelle Vertex-Position (zur Erinnerung: GetData-Node und self.pointposition eintragen) und stöpseln sie in eine 3D Vector to Scalar-Node. Als Output haben wir nun drei Scalar-Werte, für X, Y und Z. Diese verwandeln wir gleich wieder zurück in einen 3D-Vektor, mithilfe einer Scalar to 3D-Vector-Node. Allerdings verbinden wir nur den X- und Z-Wert, den Y-Wert belassen wir in der Scalar to 3D Vector-Node bei 0. Deren Output gibt uns jetzt die Anfangsposition des Vertex.

Nun brauchen wir einen Vektor, der von der aktuellen Position zur Anfangsposition zeigt. Hierfür ist ein kleines bisschen Kenntnis von Vektormathematik nötig, wir werden nämlich zwei Vektoren subtrahieren. Denn wenn man V1-V2 = V3 rechnet, dann ist V3 ein Vektor, der von der Endposition von V2 zur Endposition von V1 zeigt. Wollen wir also den Vektor, der von der aktuellen Vertexposition zur Startposition zeigt, lautet die Formel: P(start)-P(aktuell). In ICE holen wir uns dafür eine Subtract-Node. In den First-Input ziehen wir die Startposition, die wir errechnet haben und in den Second-Input die aktuelle Position (inzwischen wissen wir ja, wie wir diese herausfinden). Dieser Vektor ist jetzt unsere Kraft, die auf die Partikel wirken soll, wir ziehen den Output der Subtract-Node also in den Input unserer SetData-Node, in der self.force eingetragen ist.

Wenn wir die Simulation nun abspielen pendeln die Vertices auf und ab, nachdem sie von dem Schiff verdrängt worden sind. Allerdings ist diese Pendelbewegung absolut verlustfrei, sie wird also niemals geringer. Mit einer weiteren kleinen Funktion sorgen wir dafür, dass die Welle langsam an Kraft verliert.

« 1 2 »

home | top

cgheute.png
Blog Artist Profile Datenbank Umfragen About Contact Us Impressum Datenschutz
News
Interviews
Events
Tutorials
Reviews
Resource
Filme

Events
Festivals
Ausbildung
Software
3D-Spielfilme
Spiele-Entwickler
BluRays
Bücher
Glossar

VFX Branche
VFX Firmen
VFX Gehaltsspiegel
VFX Ausbildung
VFX Software
VFX Filme
E-Mail
Submit News
Advertise