Flash ist keine 3D Anwendung, da man aber mit Flash rechnen kann, kann man sich die x, y, z Koordinaten und die sich daraus ergebenden perspektivischen Gesetzmäßigkeiten mittels Funktionen errechnen. Ein sehr anschauliches, gut zu verstehendes Tutorial (allerdings nur in englisch) findet ihr bei http://www.kirupa.com

In meinem Tipp "programmierte Bewegung" haben wir allerlei Bewegungen im 2 dimensionalen Koordinatensystem ausgeführt.
x die horizontale Koordinate und y die vertikale. Der Nullpunkt liegt oben links. Nun kommt noch eine Koordinate hinzu. Die z Achse.

Wichtig sind folgende Punkte
a) Ein Objekt das auf der z Achse hinten liegt, muss von Objekten, die weiter vorne liegen und es überschneiden, verdeckt werden. Das regelt man über swapDepths.
b) Je weiter sich ein Objekt auf der z Achse nach hinten bewegt, desto kleiner wird es. Auch die Wege auf der x und y Achse werden nach hinten kleiner.



Stapeltiefe

Wir brauchen eine Anweisung welche die Stapelandordnung der Filme regelt. Mit der Methode swapDepths wird diese Anordnung programmiert.
mein_mc.swapDepths(Tiefe);
Der höhere Wert liegt vorne. Da hier eine hohe Z-Position den Mc nach hinten positioniert kehren wir den Spieß einfach um, indem wir negative Z-Positionen als Wert für swapDepths eingeben.
this.swapDepths(-this.z);
Eigentlich sind die negativen Werte für die autmatische Zuweisung in Flash bestimmt. Wer sich damit unwohl fühlt kann auch einen sehr hohen Wert nehmen und die z-Position davon abziehen.
this.swapDepths(10000-this.z);

Der Nullpunkt des 2 dimensionalen Koordinatensystems liegt in Flash auf der linken oberen Ecke. Dieser blöde Blickwinel wird geändert, indem der Nullpunkt unser 550x400 er Bühne versetzt wird.
origin = new Object();
origin.x = 275;
origin.y = 200;



Wir brauchen eine Formel, welche die Objekte verkleinert und die die Werte für die Bewegungen auf der x und y Achse entsprechend der Position auf der z Achse verkleinert.
Als erstes bestimmen wir einen Wert für die Brennweite
focalLength = 300;
Diese Brennweite bestimmt wieviel Perspektive man hat oder wie stark die Objekte verzerrt oder skaliert werden. Je größer der Wert desto weniger Skalierung hat man entlang der Z-Achse. 300 stellt einen guten Mittelwert dar. Am Besten ihr probiert später verschiedene Werte aus, um den Effekt zu sehen.
Jeder MC bekommt eine Variable für x-, y- und z-Position nach der die x- und y-Position und Skalierung berechnet werden.
mein_mc.x, mein_mc.y, mein_mc.z
In diesem Beispiel bekommt jeder MC einen Startwert auf den drei Koordinaten und dann folgt in einer Schleife eine Bewegung vor und zurück auf der z Achse.

this.z += speed*this.dir; if (this.z>500) { this.z = 500; this.dir = -1; } else if (this.z<0) { this.z = 0; this.dir = 1; } Wir haben hier eine einfach Vor- und Zurückbewegung, die schon auf der ersten Seite meines Tipps "programmierte Bewegung" in ähnlicher Form vorkam.

Mit diesem z-Wert, und der Brennweite focalLength wird eine Wert unter scaleRatio bestimmt, welcher die Skalierung mittels _xscale und _yscale sowie die x- und y-Postion errechnet.

var scaleRatio = focalLength/(focalLength+this.z);

Das ist wohl der wichtigste Teil, eine Formel, die ich schon lange gesucht habe.

 

this._x = origin.x+this.x*scaleRatio; this._y = origin.y+this.y*scaleRatio; this._xscale = this._yscale=100*scaleRatio; this.swapDepths(-this.z);

Hier wird nun der _x und _y Wert sowie die Skalierung und die z-Position umgesetzt. Es folgt das komplette Actionscript:

Die Startparameter, Ursprung, Brennweite Geschwindigkeit

 

origin = new Object(); origin.x = 275; origin.y = 200; focalLength = 300; speed = 20;

MovieClip.prototype.hinHer = function(startx, starty, startz, dir) { this.x = startx; this.y = starty; this.z = startz; this.dir = dir; this.onEnterFrame = function() { this.z += speed*this.dir; if (this.z>500) { this.z = 500; this.dir = -1; } else if (this.z<0) { this.z = 0; this.dir = 1; } var scaleRatio = focalLength/(focalLength+this.z); this._x = origin.x+this.x*scaleRatio; this._y = origin.y+this.y*scaleRatio; this._xscale = this._yscale=100*scaleRatio; this.swapDepths(-this.z); }; };

Ich habe mir einen MC mit einem Photo von mir erstellt. Wichtig ist, dass das Bild mit der linken oberen Kante am Mittelpunkt des MCs ausgerichtet ist. Auf der Bühne befinden sich davon 3 Instanzen, welchen die Prototype Funktion hinHer() zugewiesen wird. Die Startwerte für xyz und die Startrichtung 1 oder -1 werden erwartet.

 

pastor1.hinHer(-50, 200, 100, 1);

pastor2.hinHer(200, 200, 200, 1);

pastor3.hinHer(50, 200, 500, 1);

 

Wie schon gesagt ist der wichtige Teil scaleRatio Formel. Weil hier die perspektivische Verkleinerung der Größe und der Distanzen berechnet wird. Hat man das Prinzip erstmal verstanden, kann man alle programmierten Beweungen, für die x y Achse, die ich zuvor erklärt habe in dieses Koordinatensystem übertragen. Zum Beispiel kann man die trigonometrische Kreisbewegung mit Draufsicht (siehe Trigo) in einen liegenden Kreis umwandeln, indem man die Programmierung für die y Koordinate auf die z Koordinate überträgt.