3D GAMESTUDIO-Magazin Ausgabe 01 | Oktober 20051

3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │1

Vorwort
Inhalt
Liebe Leserin, lieber Leser,
mit dieser Ausgabe fällt der Startschuss für eine hoffentlich lange Serie eines neuen Magazins.
Einen Monat haben wir uns mit der Planung beschäftigt und an Artikeln gearbeitet, um Ihnen
möglichst viele Informationen rund um die Acknex6 Engine zu vermitteln. In dieser Ausgabe
erwarten Sie eine Menge Tutorials, Interviews mit Sebastian Leopold und Timo Stark, den
Entwicklern von Sylex 3.0 und dem kommenden Realtime-Editor GameEdit sowie einem kleinem
Preview zu GameGameEdit.
Um die nächsten Ausgaben noch besser und größer zu machen, hoffen wir auf Ihre Unterstützung!
• Normalmaps für Computerspiele erstellen
• Vektoren
• Mit Bleifuß zur Physik Engine – Part I
• Viel Rauch um nichts. Ein Nebeltutorial
• Modelldesign - Teil 1: Ein Tisch mit Blender
• Laser - und Photonentorpedoeffekte
• Bitoperatoren
• Möglichkeiten des Physiksystems in Gamestudio Commercial
• Formationsanordnungen in einem 3D Spiel
• Interview mit Sebastian Leopold (Xexes) über Sylex 3.0
• Interview mit Martin (SFMAT4) und Timo (TripleX) zu ihren derzeitigen Projekten
• Game-Edit
Der Schwierigkeitsgrad als Anzeige
In eigener Sache:
Wenn Sie der Meinung sind, einen Beitrag leisten zu können, kontaktieren Sie einen der 3DGS-Magazin
Autoren. Oder über das Forum welches auch über http://3dgsmag.ma-pre.de/forum zu erreichen ist.
Das 3DGS-MAGAZIN Team
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │2

Grundlagen
Normalmaps für Computerspiele erstellen
von Frank Geppert
Eine Normalmap ist eine Textur, die zusätzlich zu der farbliefernden Textur (Diffusemap) weitere
Informationen liefert. Diese Informationen geben dem Shaderprogramm der Grafikkarte an, aus
welcher Richtung bestimmte Pixel beleuchtet werden sollen. Damit lassen sich räumliche
Oberflächen simulieren, wo eigentlich keine Geometrie räumliche Informationen liefert.
Sehen Sie dazu folgendes Beispiel. Ich habe einen einfachen Würfel erstellt, der nur mit einer
einzigen Farbe texturiert ist und eine Normalmap erhält. Diese Normalmap soll eine Seite des
Würfels so anzeigen, als würde eine Vertiefung auf dieser existieren und eine andere Seite soll so
beleuchtet werden, als würde eine etwas herausstehende Fläche auf ihr existieren.
Um dieses Ziel zu erreichen, muss man eine Normalmap erstellen, die wie folgt aussehen könnte:
2 von den 6 Seiten des Würfels haben zusätzliche Informationen erhalten. Die anderen blieben in
diesem Beispiel flach. Sie sehen, dass z.B. die etwas helleren Teile der Normalmap dafür sorgen,
dass unser Würfel von unten beleuchtet erscheint und die dunkelblauen Streifen lassen den Würfel
von oben beleuchtet erscheinen. Analog dazu gibt es Informationen für die Beleuchtung von den
jeweiligen Seiten, je nachdem wie die Werte im RGB-Kanal verteilt sind.
Mit dieser Methode lässt sich beliebige Geometrie vortäuschen, wo gar keine Geometrie ist. Ein viel
beeindruckenderes Beispiel dazu sehen Sie weiter unten.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │3

Erstellen von Normalmaps aus Texturen
Normalmaps lassen sich auf verschiedene Weise erstellen. Eine Methode ist es, diese in einem
Grafikprogramm zu zeichnen. Photoshop und GIMP haben zudem jeweils Plugins, mit denen man
Normalmaps aus Grafiken berechnen lassen kann. Diese Methode geht sehr einfach und schnell,
führt aber nicht immer zu den gewünschten Ergebnissen.
1. Ich werde dazu ein kurzes Beispiel zeigen, wie man solche Texturen in dem
Grafikprogramm “The GIMP” erstellen kann. Dazu benötigen Sie ein Normalmap-Plugin für
diese Software.
2. Das Plugin ist schnell mit der Internetsuche und den Begriffen “Normalmap GIMP Plugin”
gefunden und mit Hilfe der Anleitung installiert.
3. Nach der Installation finden Sie unter Filter / Abbilden / Normalmap dieses Plugin Das
Plugin präsentiert sich wie folgt:
4. Wählen Sie ihren Filter und ändern Sie bei Bedarf die Parameter. Ich persönlich mag den
“Sobel” Filter am meisten, da dort die Struktur am besten herausgefiltert wird.
Schauen Sie sich bei Bedarf den 3D Preview mit dem Schalter unter dem Vorschaufenster an.
Dieses 3D-Bild gibt einen ersten Eindruck, wie der Effekt im Spiel aussehen könnte. Dabei ist es
sogar möglich, eine weitere Textur, die in GIMP geöffnet sein muss über dieses 3D-Objekt zu
überlagern. So könnten Sie prüfen, wie der Effekt mit der Diffusemap und der Normalmap
aussehen könnte. Allerdings sieht man die Struktur besser, wenn man zum Testen erst einmal eine
Farbtextur weglässt.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │4

Meine Erfahrungen mit diesem Tool zeigen, dass sich Graustufen- und Bumpmap-Grafiken besser
eignen, als reine Farbgrafiken, um daraus Normalmaps zu generieren. Das Ergebnis zeigt
tatsächlich eine interessante Struktur, die man bereits im 3D-Preview-Fenster bestaunen kann.
Allerdings sind extreme Tiefen und Höhen sowie eine Verfeinerung der Geometrie damit nicht
realisierbar. Dafür empfehle ich das aufwändigere aber leistungsstärkere Verfahren, dass ich
anschließend erklären werde.
Erstellen von Normalmaps aus Geometrie
Sie haben einen Spiele-Charakter, der in sehr detaillierter Form vorliegt (z.B. mehr als 200.000
Polygone). Allerdings verlangt eine Spiele-Engine ein lowpoly-Modell mit z.B. 3000 Polygonen. Mit
der Normalmapping-Technik können Sie ein Brücke zwischen diesen beiden Welten schlagen. Die
Vorgehensweise ist dabei wie folgt:
Sie erstellen ein Highpoly und ein Lowpoly Modell. Lassen Sie eine Normalmap aus dem Highpoly-
Modell berechnen (Melody von nVidia, Lightwave oder 3Dsmax) wenden Sie diese Normalmap auf
das Lowpoly-Modell an.
Hier sehen Sie ein Beispiel. Ich habe eine beliebiges Modell, das mit Lightwave geliefert wurde,
geladen. Dieses Modell bestand aus ca. 4.000 Polygonen, die ein Subpatch-Modell von fast 50.000
Polygonen lieferten. Nachfolgend sehen Sie links das Original Modell (high poly), in der Mitte das
dazugehörige lowpoly Modell und anschließend das gleiche lowpoly Modell mit der Normalmap.
Sie werden vermutlich den Unterschied zwischen der highpoly Figur und der lowpoly Figur mit der
Normalmap nur an den Umrissen festmachen können (z.B. die eckige Wade), denn die Beleuchtung
erfolgt wie bei dem Original, auch wenn die Geometrie viel weniger Details enthält. Diese Technik
ist auf die beliebigsten Modelle anwendbar und ermöglicht viel detailliertere Welten, wie viele von
Ihnen vielleicht schon in den Spielen “Doom3, Riddick oder F.E.A.R” sehen konnten.
Ein weiterer Vorteil von Normalmaps ist, dass diese Technik nicht nur mit weniger Details in der
Geometrie auskommt, sondern teilweise auch mit recht kleinen Texturen noch beeindruckend
aussieht. Das liegt daran, dass viele zusätzliche Informationen durch die Beleuchtung und die
Specularity-Effekte hinzukommen. Damit erhöht sich der Detailgrad allein durch die Funktionen des
Shaderprogrammes mehr, als man vielleicht durch eine detaillierte Textur hinzufügen könnte.
Zusätzlich besitzen einige Shader-Programme die Fähigkeit, über den Alpha-Channel der Diffuse-
Map die Specularity verschiedener Bereiche der Grafik zu steuern.
Ich hoffe, dass ich Ihnen einen ersten Einblick in die Arbeit mit Normalmapping liefern konnte.
Wenn es weitere Fragen zu dem Thema gibt, bin ich ich unter info@geppert-software.de zu
erreichen.
Frank Geppert
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │5

Hallo
Vektoren
von Timo Stark aka Triple-X
In diesem Tutorial werde ich auf Vektoren eingehen. Vektoren werden in der 3D Grafik sehr häufig
gebraucht, werden aber leider meistens, gerade von Anfängern, nicht verstanden. Aus diesem
Grund werde ich in diesem Tutorial darauf eingehen, was Vektoren überhaupt sind, was Sie für
eine Rolle in der Grafikprogrammierung spielen, wie man mit ihnen rechnet und welche
Vektorbefehle es in 3D Gamestudio gibt.
Für dieses Tutorial sollten Sie etwas Mathematische Kenntnisse mitbringen. Erfahrungen in C-Script
sind nicht nötig, da in diesem Tutorial, außer im letzten Kapitel, nicht auf C-Script eingegangen
wird. Falls Sie ein Tutorial für C-Script suchen, empfehle ich Ihnen das Handbuch oder mein C-
Script Tutorial für Anfänger erreichbar unter: http://www.hawkgames.de/Tutorial.php
Viel Spaß beim lesen, TripleX
Was sind Vektoren?
Nun was sind Vektoren? Ganz allgemein gesagt, ist ein Vektor eine Ansammlung von Werten. Wie
viele Werte einen Vektor bilden hängt von der Anzahl der Dimensionen ab. In einem ndimensionalen
Raum hat ein Vektor n Werte. Jeden dieser Werte nennt man Vektorkomponente.
Grundsätzlich können Vektoren viele Daten darstellen. Es hängt immer nur von der Interpretation
des Vektors ab.
Als Beispiele:
1) Positionsvektor (Drei Dimensionen: X/Y/Z Koordinate)
2) Richtungsvektor (Drei Dimensionen: Pan/Tilt/Roll Winkel)
3) Farbvektor (Drei Dimensionen: Rot/Grün/Blau)
Positionsvektoren
Ein Positionsvektor beschreibt immer eine Position in einem n-dimensionalen Koordinatensystem.
In 3D Gamestudio werden sowohl 3-Dimensionale Vektoren zur Beschreibung von Welt-
Koordinaten als auch 2-Dimensionale Vektoren zur Beschreibung von Bildschirm-Koordinaten
genutzt. Nun was ist überhaupt ein Koordinatensystem und eine Koordinate? In der
Grafikprogrammierung wird größtenteils mit den kartesischen Koordinatensystem gearbeitet. Im
folgenden Bild sehen Sie ein Beispiel für das 3-dimensionale kartesische Koordinatensystem:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │6

Diese Grafik zeigt das normale kartesische Koordinatensystem. Zu beachten ist, dass in 3D
Gamestudio die Y und die Z Achse vertauscht sind. Die Y Achse geht also in die Tiefe und die Z
Achse nach oben.
Für dieses Koordinatensystem wird eine Einheit festlegt (in 3D Gamestudio ist das 1 Quant). Nun
lassen sich bestimmte Positionen mit Hilfe von Positionsvektoren treffend beschreiben. Zum
Beispiel der Punkt (0 | 2 | 5) (Schreibweise eines Vektors: ( X-Komponente, Y-Komponente, Z-
Komponente )) liegt 5 Einheiten an der Z Achse und 2 Einheiten an der Y Achse entlang. Also
diagonal nach oben in die Tiefe.
Zu beachten ist, dass jedes 3D-Objekt sein eigenes relatives Koordinatensystem bildet.
Beispiel: Ein Haus befindet sich auf der absoluten Position (10 | 20 | 10). Ein Mensch hat die
Position (5 | 20 | 30). Vom Menschen aus gesehen besitzt das Haus also die Position (5 | 0 | 20).
Der Mensch bildet also ein eigenes relatives Koordinatensystem mit den Ursprung (5 | 20 | 30).
Die Achsenrichtung und Ursprungsposition stimmen also nicht mit der Achsenrichtung und der
Ursprungsposition des absoluten Koordinatensystems überein.
Richtungsvektoren
Formal (also von der Schreibweise her) unterscheiden sich Richtungsvektoren nicht von
Positionsvektoren. Sie werden nur anderes interpretiert. Genau wie bei Positionsvektoren, richtet
sich die Anzahl der Vektorkomponenten nach der Anzahl der Dimensionen. Zur besseren
Vorstellung: In einem 2-Dimensionalen Raum brauchen Sie 2 Werte um eine Richtung zu
bestimmen, in einem 3-Dimensionalen 3 Werte und so weiter. Also braucht man n
Vektorkomponenten für n Dimensionen.
Jede Vektorkomponente in einem Richtungsvektor besitzt normalerweise nur Werte zwischen 0 und
1. Das heißt er besitzt maximal die Länge 1.
Beispiel: Ein Hund besitzt die Position (10 | 0 | 0). Vom Nullpunkt ausgesehen besitzt der Hund
also die Richtung (1 | 0 | 0).
Sehr oft werden Richtungsvektoren auch zur Bestimmung einer Bewegungsrichtung genutzt, wobei
zu beachten ist, dass bei Bewegungsvektoren auch noch die Geschwindigkeit des jeweiligen
Objektes mit einbezogen wird.
Beispiel: Ein Mann bewegt sich mit der Geschwindigkeit (7 | 0 | 0). Er bewegt sich also mit 7
Einheiten pro Sekunde an der X Achse entlang. Setzt man nun statt (7 | 0 | 0), (1 | 0 | 0),
verändert sich nicht die Richtung, sondern nur die Geschwindigkeit mit der sich der Mann bewegt
(jetzt nur noch eine Einheit pro Sekunde).
Rechnen von Vektoren
Im folgenden werde ich auf das Rechnen mit Vektoren eingehen. Grundsätzlich kann man mit
Vektoren genauso rechnen wie mit Skalaren (reelle Zahl), bis auf wenige Ausnahmen.
Vektor-Addition und -Subtraktion
Addition und Subtraktion mit Vektoren funktioniert genauso wie Addition und Subtraktion bei
normalen reellen Zahlen.
Beispiel: A und B sind Vektoren.
a + b = (xa + xb | ya + yb | za + zb)
a - b = (xa - xb | ya - yb | za - zb)
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │7

Zur Addition und Subtraktion von Vektoren müssen sie also legendlich alle Vektorkomponenten
miteinander addieren/subtrahieren.
Addition und Subtraktion von Vektoren wird sehr oft zum Bewegen von Objekten benötigt. Ein
weiteres Beispiel: Eine Pflanze soll zu der Position (-10 | 23 | 10) der Vektor (0 | 7 | 2) addiert
werden. Die neu berechnete Position der Pflanze ist: (-10 | 30 | 8).
Der entsprechende Befehl in C-Script ist vec_add(vector1,vector2); und vec_sub(vector1,vector2);
Auf Vektorbefehle wird im weiteren genauer eingegangen.
Vektor Multiplikation und Division
Bei der Multiplikation und der Division von Vektoren kann man zwischen zwei Arten unterscheiden
1) Multiplikation / Division eines Vektors mit einer reellen Zahl (Skalar).
2) Multiplikation / Division eines Vektors mit einem anderen Vektor.
Vektor Multiplikation und Division mit reellen Zahlen
Die Multiplikation/Division eines Vektors mit einer reellen Zahl ist sehr einfach zu verstehen. Bei
einer solchen Rechnung wird einfach jede Vektorkomponente mit dem Skalaren multipliziert.
Beispiel A = Vektor, s = Reelle Zahl
A * s = (xa * s | ya * s | za * s)
A / s = (xa / s | ya / s | za / s)
Durch die Multiplikation/Division eines Vektors mit einem Skalar ist es möglich die Länge eines
Vektors zu stauchen bzw. sie zu erhöhen. Dies ist z.B. sehr nützlich bei Bewegungsvektoren
(erhöhen/verringern der Geschwindigkeit). Bei der Multiplikation eines Richtungsvektors mit einem
Skalar bleibt die eigentliche Richtung bestehen.
Als Veranschaulichung: A = Vektor der Länge 1
Vektor A * 1
-------------------->
Vektor A * 2
----------------------------------------->
Vektor A * 0.5
---------->
In 3D Gamestudio übernimmt vec_scale(Vektor,Zahl); diese Funktion.
Vektor Multiplikation und Division mit einem Vektor
Grundsätzlich kann man Vektoren auf mehrere Arten miteinander multiplizieren/teilen:
1. Komponentenweise Multiplikation/Division zweier Vektoren.
2. Das Kreuzprodukt
3. Das Punktprodukt
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │8

Komponentenweise Multiplikation/Division zweier Vektoren
Das Komponentenweise multiplizieren und teilen zweier Vektoren funktioniert, wie Sie sich
wahrscheinlich schon denken genauso wie das addieren und subtrahieren zweier Vektoren.
a * b = (xa * xb | ya * yb | za * zb)
a / b = (xa / xb | ya / yb | za / zb)
Diese Möglichkeit der Multiplikation ist in der Grafikprogrammierung allerdings kaum notwendig.
Trotzdem ein Beispiel:
Die Höhe (Y Achse) eines Menschen (10 | -10 | 5) soll vierfach erhöht werden. Dafür wird die
aktuelle Position des Menschen mit dem Vektor (1 | 4 | 1) multipliziert.
a * b = (xa * xb | ya * yb | za * zb) --->
(10 | -10 | 5) * (1 | 4 | 1) = (10 * 1 | -10 * 4 | 5 * 1) = (10 | -40 | 5)
Vergessen Sie nicht, dass wenn sich die Position bei einer Multiplikation nicht verändern soll, in der
Vektorkomponente eins stehen muss und nicht null (0 * Zahl = 0).
Das Kreuzprodukt
Neben der Komponentenweise Multiplikation eines Vektors gibt es auch noch die Möglichkeit des
Kreuzproduktes. In der Mathematik wird dieses Kreuzprodukt nicht über das "Mal Zeichen" sondern
über das Multiplikationskreuz "x" angegeben.
Im folgenden Beispiel sind A und B wie immer Vektoren (hier Richtungsvektoren).
a x b = ((ya * zb) - (za * yb) | (za * xb) - (xa * zb) | (xa * yb) - (ya * xb))
Diese, zugegebenermaßen, komplizierte Rechnung hat bei Richtungsvektoren den Sinn, dass der
neu errechnete Vektor senkrecht auf den beiden anderen Vektoren steht. Dies funktioniert
natürlich nur bei Richtungsvektoren. Ein Vektor kann unmöglich auf einen Positionsvektor
senkrecht stehen (wo ist denn auf einen Punkt senkrecht).
Folgendes Bild zur Veranschaulichung:
B = Erster Vektor
A = Zweiter Vektor
Blauer / Hellgrüner Vektor = (Umgekehrter) Ergebnisvektor -> Steht Senkrecht auf B und A.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │9

Das Punktprodukt
Nun die letzte Möglichkeit des multiplizieren / teilen zweier Vektoren. Das Punktprodukt. Das
besondere an dem Punktprodukt ist, dass das Ergebnis kein dritter Vektor sondern eine Zahl ist.
Der Sinn des Punktproduktes ist es, den Winkel zwischen zwei Richtungsvektoren zu bestimmen.
a * b = (xa * xb) + (ya * yb) + (za * zb)
Das Punktprodukt funktioniert nur mit normalisierten Richtungsvektoren. Das heißt es funktioniert
nur mit Richtungsvektoren der Länge 0 bis 1. Auf normalisierte Vektoren werde ich später noch
gesondert eingehen.
Das Ergebnis dieses Punktproduktes ist der Kosinus des Winkels der von den beiden
Richtungsvektoren eingeschlossen ist. Beeindruckend oder?
Aus dem Kosinus eines Winkels können sie mit Hilfe der acos(Kosinus); ganz einfach einen
"echten" Winkel berechnen.
In 3D Gamestudio übernimmt vec_dot(Vektor1,Vektor2); diese Funktion.
Die Länge eines Vektors
Als erstes muss definiert werden was die Länge eines Vektors überhaupt ist. Grundsätzlich ist
wichtig zu sagen, dass die Länge eines Vektors nur bei einem Richtungsvektor Sinn macht. Welche
Länge sollte auch eine Position haben?
Was genau die Länge eines Vektors ist, kann man am besten mit Hilfe eines Beispiels erklären.
Ein Mensch bewegt sich mit der Geschwindigkeit (2 | 4 | 3). Also um 2 Quants/sec an der X Achse,
4 Quants/sec an der Y Achse und 3 Quants/sec an der Z Achse. Um wie viel sich der Mensch jetzt
insgesamt bewegt gibt die Länge des Vektors wieder.
Die Länge des Vektors kann man mit Hilfe des Satzes von Pythagoras berechnen.
Um die Vektorlänge besser zu verstehen, wenden wir den Satz des Pythagoras als Erstes im 2-
Dimensionalen Raum an. Der hier gezeigte Vektor besitzt die Position (C | Schnittpunkt der roten
Linie mit C). Die Vektorlänge ist A (die rote Linie). Die Punkte (0 | 0), (C | Schnittpunkt der
roten Linie mit C) und (C | 0) bilden ein rechtwinkliges Dreieck. Daher ist der Einsatz des Satz des
Pythagoras möglich.
Also ist die Länge eines 2-Dimensionalen Vektors:
L = Wurzel(xa² + ya²)
Wie sie vermutlich schon selber folgern können ist also die Formel für die Berechnung der Länge
eines Vektors im 3-Dimensionalen Raum:
L = Wurzel(xa² + ya² + za²)
Diese Funktion übernimmt vec_length(Vektor); in C-Script für Sie.
Dadurch, dass Sie jetzt wissen wie man die Länge eines Vektors berechnet, können Sie auch die
Distanz zwischen zwei Punkten berechnen. Wie geht das werden Sie sich vielleicht fragen. Nun
ganz einfach. Sie bilden durch die Subtraktion des 1. Vektors von den 2. Vektor einen
"Verbindungsvektor". Jetzt berechnen Sie die Länge des Vektors. Dies ist die Distanz zwischen den
beiden Positionsvektoren.
Ein Beispiel indem Sie die Entfernung auch ohne Berechnung sehen würden, damit Sie es glauben
Eine Frau an der Position (10 | 50 | 50) würde gerne Ihre Entfernung zu den Flugzeug (10 | 1000 |
50) wissen. Wie kann sie diese Entfernung berechnen?
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │10

Zuerst der Verbindungsvektor V:
V = A - B
V = (10 | 50 | 50) - (10 | 1000 | 50)
V = (0 | -950 | 0)
Jetzt wird also noch die Länge dieses neu errechneten Vektors bestimmt:
L = Wurzel(xv² + yv² + zv²)
L = Wurzel(0 * 0 + -950 * - 950 + 0 * 0)
L = Wurzel(902500);
L = 950;
Die Distanz beträgt also 950 Quants, wie Sie zweifellos sofort gesehen haben ;-) Da dieses Beispiel
sehr einfach war rechnen Sie es am besten noch mal mit der Position Frau = (0 | 2 | -30) und
Flugzeug = (620 | 1200 | 2) aus. Hier sehen Sie die Distanz nicht auf den 1. Blick. Sie sollten
ungefähr auf das Ergebnis 1343 kommen. In C-Script übernimmt übrigens die Funktion
vec_dist(vector1,vector2); diese Aufgabe.
Vektoren in 3D-Gamestudio und C-Script
Das schwierigste haben Sie jetzt hinter sich gebracht. Nun kommt der praktische Teil dieses
Tutorials der sich mit der Frage beschäftigt, wie man Vektoren in C-Script benutzen kann.
Definieren von Vektoren
In 3D-Gamestudio haben Vektoren immer 3-Vektorkomponenten. Dies liegt einfach daran, dass
wie der Name von 3D-Gamestudio schon sagt, mit einem Vektor ein 3-Dimensionaler Raum
beschrieben wird. Definieren kann man den Vektor über das var Keyword.
Var Vektorname[3];
Der Name ist beliebig. Ich würde allerdings empfehlen, damit Vektoren auch als solche erkenntlich
sind, den Namen mit einem bestimmten Prä oder Suffix (_vec o.ä.) versehen. Falls der Vektor
einen vordefinierten Wert haben soll geht dies über folgende Definierung:
Var Vektorname[3] = Wert X, Wert Y, Wert Z;
Vektoren können auch in Funktionen, also lokal, definiert werden. Auf eine Vektorkomponente
kann mit folgenden Werten zugegriffen werden:
Vektorname[0] = Wert; //Greift auf den X Wert zu
Vektorname[1] = Wert; //Greift auf den Y Wert zu
Vektorname[2] = Wert; //Greift auf den Z Wert zu
Vektorname.x = Wert; //Greift auf den X Wert zu
Vektorname.y = Wert; //Greift auf den Y Wert zu
Vektorname.z = Wert; //Greift auf den Z Wert zu
Vektorname.pan = Wert; //Greift auf den X Wert zu
Vektorname.tilt = Wert; //Greift auf den Y Wert zu
Vektorname.roll = Wert; //Greift auf den Z Wert zu
Vektorname.blue = Wert; //Greift auf den X Wert zu
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │11

Vektorname.green = Wert; //Greift auf den Y Wert zu
Vektorname.red = Wert; //Greift auf den Z Wert zu
Wie Sie sehen macht es C-Script Ihnen sehr einfach auf Vektoren zuzugreifen. Wichtig ist, dass es
keinen Unterschied macht ob Sie
Oder
Vektorname.blue = 128;
Vektorname[0] = 128;
schreiben. Es ist nur einfacher für den Programmierer (also Sie) zu verstehen wie dieser Vektor
interpretiert wird.
Wichtig ist, dass bei lokal definierten Vektoren nur der 1. Interpretationsweg (also über
[0]/[1]/[2]) als richtig anerkannt wird.
X/Y/Z wird bei Positionsvektoren, Pan/Tilt/Roll bei Richtungsvektoren und Blue/Green/Red bei
Farbvektoren genutzt.
Besonderheiten von Vektoren in 3D-Gamestudio
Folgende Besonderheiten sind bei Vektoren in 3D-Gamestudio zu beachten:
1) Die Y und die Z Achse sind im Koordinatensystem vertauscht. Das heißt, dass die Z-Achse in die
Höhe und die Y Achse in die Tiefe geht.
2) Mit Vektoren kann man nicht wie mit normalen reellen Zahlen rechnen. Das heißt eine direkte
Zuweisung („=“), oder das einfache addieren („+“) zweier Vektoren mit einfachen Rechenzeichen
ist nicht möglich. Hierzu gibt es Befehle auf die ich im folgenden eingehen werde. Sehr wohl
können allerdings alle Grundrechenarten mit einzelne Vektorkomponenten ( vec1.x = vec2.x; )
durchgeführt werden. Auf diesen Weg sind alle oben angegeben Vektorrechnungen auch in C-Script
möglich.
Vec_Set(Vektor1,Vektor2);
Mit Hilfe dieses Befehls werden alle 3 Vektorkomponenten des ersten Vektors mit dem 3
Vektorkomponenten des zweiten Vektors überschrieben.
Beispiel:
Var Vec1[3] = 10,20,30 ;
Var Vec2[3] = 2,15,22 ;
Vec_set(Vec1,Vec2) ; /* Die Drei Vektorkomponenten von Vec1 nach dieser Anweisung: (2 | 15 |
22) */
//das gleiche (nur etwas schneller) wie:
Vec1.x = Vec2.x;
Vec1.y = Vec2.y ;
Vec1.z = Vec2.z ;
Vec_Add(Vektor1,Vektor2);
Mit Hilfe dieses Befehls werden alle 3 Vektorkomponenten des ersten Vektors mit dem 3
Vektorkomponenten des zweiten Vektors addiert. Das Ergebnis dieser Anweisung wird in den
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │12

ersten Vektor geschrieben.
Beispiel:
Var Vec1[3] = 10,20,30 ;
Var Vec2[3] = 2,15,22 ;
Vec_add(Vec1,Vec2) ; /* Die Drei Vektorkomponenten von Vec1 nach dieser Anweisung: (12
| 35 | 52) */
//das gleiche (nur etwas schneller) wie:
Vec1.x += Vec2.x;
Vec1.y += Vec2.y ;
Vec1.z += Vec2.z ;
Vec_Sub(Vektor1,Vektor2);
Mit Hilfe dieses Befehls werden alle 3 Vektorkomponenten des ersten Vektors mit dem 3
Vektorkomponenten des zweiten Vektors subtrahiert. Das Ergebnis dieser Anweisung wird in den
ersten Vektor geschrieben.
Beispiel:
Var Vec1[3] = 10,20,30 ;
Var Vec2[3] = 2,15,22 ;
Vec_add(Vec1,Vec2) ; /* Die Drei Vektorkomponenten von Vec1 nach dieser Anweisung: (8
| 5 | 8) */
//das gleiche (nur etwas schneller) wie:
Vec1.x -= Vec2.x;
Vec1.y -= Vec2.y ;
Vec1.z -= Vec2.z ;
Vec_Scale(Vektor1,Zahl);
Mit Hilfe dieses Befehls werden alle 3 Vektorkomponenten des ersten Vektors mit der angegeben
Zahl multipliziert (siehe Oben). Das Ergebnis dieser Anweisung wird in den ersten Vektor
geschrieben.
Beispiel:
Var Vec1[3] = 10,20,30 ;
Var factor = 10;
Vec_add(Vec1,factor) ; /* Die Drei Vektorkomponenten von Vec1 nach dieser Anweisung:
(100 | 200 | 300) */
//das gleiche (nur etwas schneller) wie:
Vec1.x *= factor;
Vec1.y *= factor ;
Vec1.z *= factor ;
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │13

Vec_Length(Vektor);
Mit Hilfe von Vec_Length können sie schnell die Länge (s.o.) eines Vektors bestimmen. Die Länge
eines Vektors ist in 3D Gamestudio nichts anders als seine Distanz zum Nullpunkt (0 | 0 | 0, oder
der vordefinierte Vektor: nullvector).
Vec_Dist (Vektor1,Vektor2);
Mit Hilfe von Vec_Dist können sie schnell die Entfernung zwischen zwei Vektoren (s.o.) bestimmen.
Die Distanz wird von dieser Funktion zurückgegeben („Return-Value“).
Vec_inverse (Vektor);
Die Funktion vec_inverse kehrt den angegeben Vektor um. Das heißt, dass sie jede
Vektorkomponente mit -1 multipliziert.
Vec_dot(Vektor1,Vektor2);
Diese Funktion liefert das Punktprodukt der beiden Vektoren zurück. Grundsätzlich macht sie
genau das, was wir oben beschrieben haben.
Vec_normalize (Vektor,Zahl);
Diese Funktion normalisiert den angegeben Vektor. Besonders an dieser Funktion ist die
angegebene Zahl. In Gegensatz zu dem mathematisch korrekten normalisieren auf eine Länge
unter 1, kann der Vektor auch auf eine andere Vektorlänge (angegeben mit „Zahl“) normalisiert
werden. Folgender Algorithmus wird hierbei angewandt:
temp = vec_length(Vektor.x);
Vektor.x = Vektor.x / temp * zahl;
my.y = Vektor.y / temp * zahl;
my.z =Vektor.z / temp * zahl;
Vec_To_angle (Vektor Angle, Richtungsvektor);
Diese erste etwas komplexere Vektor-Funktion in C-Script. Diese Funktion berechnet aus dem Wert
des Richtungsvektor, den Pan/Tilt und Roll Wert und schreibt diesen in den ersten Vektor. Mit
dieser Funktion kann zum Beispiel ein Entity in eine bestimmte Richtung gedreht werden.
// hole die Richtung von der Entity MY zur Entity YOU
vec_set(temp,your.x); //setzte Temp auf your.x
vec_sub(temp,my.x); //ziehe von temp.x, my.x ab -> Bewegungsvektor entsteht
vec_to_angle(my.pan,temp);// Rechne dieses Bewegungsvektor (vom Nullpunkt aus gesehen)
in Richtungswinkel um und setzte die Werte in den my.pan Vektor
Vielleicht ist dieser Code nicht sehr schnell zu verstehen, aber machen Sie sich am besten eine
Zeichnung in einem 2-Dimensionalen Koordinatensystem zur besseren Vorstellung. Sie werden
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │14

sehen dass das Ergebnis stimmt.
Vec_Rotate(Richtungsvektor, Vektor Angle);
Die zweite etwas komplexere Vektor-Funktion. Diese Funktion dreht die Richtung des ersten
Vektors um die Pan, Tilt und Roll Werte des zweiten Vektors. Hört sich kompliziert an, ist aber an
einem Beispiel sehr einfach zu verstehen.
Vec_set(temp.x,vector(50,0,0)); //setzt temp Vektor auf (50 | 0 | 0)
vec_rotate(temp.x,camera.pan); //rotiert temp Vektor um Kamera Drehung
vec_add(temp.x,camera.x); //addiert die Kameraposition zu dem Temp Vektor
Nach dieser Anweisung ist der Vektor temp.x genau 50 Quants VOR der Kamera
Vec_Cross(Vektor1,Vektor2,Vektor3);
Diese Funktion ist leider nicht in C-Script vorhanden. Daher müssen wir sie auf wohl oder über
selber schreiben. Folgende Funktion bildet das Kreuzprodukt aus Vektor1 und Vektor2 und schreibt
das Ergebnis in Vektor3.
function vec_cross(vec1,vec2,vec3)
{
vec_set(vec3.x,vector((vec1.y * vec2.z) - (vec1.z * vec2.y),(vec1.z * vec2.x) -
(vec1.x * vec2.z),(vec1.x * vec2.y) - (vec1.y * vec2.x)));
}
Ich hoffe, dass dieses Tutorial Ihnen einen Einblick in die große Welt der Vektor-Mathematik gab.
Falls nicht, oder falls noch Fragen offen sind, senden Sie mir bitte eine Email an
TripleX@hawkgames.de .
Vielen Dank für das lesen
Timo Stark aka Triple-X
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │15

Mit Bleifuß zur Physik Engine – Part I
von Ruben Aster aka Asse
Erstellen Sie im ersten Teil dieses Workshops einen physikgesteuerten Ferrari F360 mit einigen
Hindernissen.
Einleitung
Begrüßung
Willkommen zum ersten Teil meines Workshops über eines der besten Plugins, welches z.Zt.
kostenfrei für 3D GameStudio erhältlich ist – Newton Game Dynamics.
Viele kennen es und fast genauso viele haben Probleme es richtig einzusetzen. Daher hoffe ich,
dass zum Ende dieses Tutorials einige Verwirrungen geklärt sind und Sie die Funktionsweise von
Newton Game Dynamics (im weiteren NGD) besser verstanden haben. Um dies zu erreichen,
werden Sie einen physikgesteuerten Ferrari F360 erstellen und diesem einige Physikobjekte in den
Weg legen.
Ich habe bereits ein Level und eine dazugehörige Skriptdatei angefertigt, welche nur noch
bearbeitet werden muss, damit ich nicht weiter auf das Drumherum eingehen brauche.
Das wird gebraucht
• die Dateien vom Workshop,
http://www.gfxtreme.de/files/3dgs/workshop_newton01/ngd_workshop01.zip
• 3D GameStudio Extra, Standart, Commercial oder Pro
• Newton Game Dynamics 1.51 Plugin für 3DGS
• Das Plugin finden Sie auf dieser Seite (ganz unten):
http://www.physicsengine.com/downloads.html
Sie können dabei wählen, ob Sie nur das Plugin oder auch noch verschiedene Demos und Tutorials
als Bundle runterladen möchten. Dabei empfehle ich selbst 56k Usern wie mir das 30MB Package,
da wirklich einige sehr interessante Beispiele dabei sind, welche die vielfältigen Möglichkeiten von
NGD demonstrieren.
Kurze Erklärung
Da wir uns hier im ersten Teil - also sozusagen der Vorbereitung - befinden, wird das Skripten mit
NGD nur oberflächlich behandelt. Sie werden die meisten Physik-Werte, ähnliche wie bei den 3DGS
Templates, direkt in WED setzen. Uninteressant wird es jedoch trotzdem nicht werden, denn das
NGD Plugin ist in erster Linie dafür gedacht, so einfach gehandhabt zu werden.
Dennoch ist es ein Vorteil dann im zweiten Teil zu lernen, wie z.Bsp. physikalische Werte gelesen
werden um etwa einen Tacho für unseren Ferrari zu erstellen, ein Motorengeräusch zu erzeugen,
anhand der Reifenreibung quietschende Reifen zu simulieren oder einfach nur einen
überschlagenen Wagen wieder zu reseten.
Also dann, geben wir Gas!
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │16

Vorbereitung
Um ein komplett eigenständiges Projekt zu erstellen, müssen Sie aus Ihrem 3D
GameStudio\template\ Ordner einige Dateien von Newton kopieren. Der Übersicht halber habe ich
im Workshop-Ordner zwei Unterordner angelegt und diese schon in der newton01.wdl definiert.
Kopieren Sie die Dateien wie folgt:
newton.dll, newtonsplash.tga, newton.wdl, newtonScript2.wdl, newtonVehicle.wdl nach Workshop -
Newton Physics P1\
click.wav, door_cl.wav, door_op.wav, hit.wav nach Workshop - Newton Physics P1\sounds\
Als nächstes bereiten wir unser Skript für Newton vor.
Öffnen Sie die newton01.wdl und linken Sie als Erstes die wdls von Newton gleich unter dem
Kommentar „// hier newton wdls linken“.
include ;
include ;
include ;
Unter dem Kommentar „// hier splashscreen und cls datei definieren“ geben Sie den folgenden
Code ein, welcher den Splashscreen mit dem Newtonlogo und die Newton Hintergrund-Map
definiert.
bmap splashscreen = &ltnewtonsplash.tga>;
string newtonLevel_cls = &ltnewton01.cls>;
Die Newton-Hintergrund-Map (.cls) wird von NGD benötigt um Kollision mit der Levelgeometrie zu
simulieren. Erstellt wird diese Datei automatisch beim Starten eines Levels aus WED. Wichtig ist
nur, dass das Level vorher abgespeichert (nicht mit kompilieren verwechseln) wurde, damit die .cls
aus der aktuellen .wmp generiert werden kann. Sollten Sie sich also mal wundern, warum Sie
durch eine Mauer oder ähnliches durchfahren können, so haben Sie nach einer Änderung der
Geometrie nicht gespeichert.
Zu guter letzt müssen wir noch unter dem Kommentar in der main Funktion „// hier Newton Map
erstellen„ die Hintergrund-Map für Newton erstellen lassen:
wait(1);
dll_handle = newtonHandle;
NewtonAddMap(wmb_Level, splashscreen);
Damit haben Sie alle Vorbereitungen abgeschlossen und können nun mit der Erstellung eines
Newton-Projekts beginnen!
Das Fahrzeug erstellen
Skripten
Ich hoffe Sie sind nicht allzu schreibfaul, denn jetzt sind erstmal ein paar Zeilen Code fällig. Doch
keine Sorge, ich werde alles erklären, sodass Sie nicht im Dunkeln tappen.
Definieren Sie zunächst einen Entity-Pointer, mit welchem wir später auf den Wagen zugreifen
können. Falls Sie nicht wissen wo, dann suchen Sie nach dem Kommentar „// hier entity-pointer
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │17

festlegen“.
entity* p_F360;
Legen wir nun eine Aktion für unseren Ferrari an (die Kommentarzeilen dürfen nicht vergessen
werden, Erklärung folgt später noch):
// uses mass, linear_drag, angular_drag_x, angular_drag_y, angular_drag_z, health,
shape_factor; // uses collision_sph_box, start_active, compound_collision,
destructible, spawn_children; // uses car_topSpeed, car_maxToque; action newton_F360
{
var car;
// weise den pointer p_F360 zu
p_F360 = my;
// erstelle den wagen durch newton
NewtonCreateVehicle (wood_material, VehicleTireEvent, VehicleBeginEvent,
VehicleEndEvent);
dll_handle = newtonHandle;
car = NewtonGetBody (my);
// kontrolliere den wagen per skript
NewtonSetBodyAutoActiveState (car, 0);
NewtonSetBodyActiveState (car, 1);
// setze schwerkraft
NewtonSetBodyForceAndTorque (car, VehicleForceEvent);
// while loop zum steuern des wagens
while (1)
{
werden
// umdrehung und reifenstellung zurücksetzen, damit die werte nicht addiert
my.carEngineTorque = 0.0;
my.carSteerTorque = 0.0;
if(key_a)
{
}
// volle Reifenstellung links
my.carSteerTorque = 1.0;
if(key_d)
{
// volle Reifenstellung rechts
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │18

}
}
}
my.carSteerTorque = -1.0;
if(key_w)
{
}
// vollgas positiv
my.carEngineTorque = my.car_maxToque;
if(key_s)
{
}
// halb vollgas negativ
my.carEngineTorque = -my.car_maxToque * 0.5;
wait(1);
Über dieser Aktion legen Sie zwei Funktionen an, die Newton zum erstellen des Wagens benötigt.
Mit Hilfe dieser Funktionen können z.Bsp. quietschende Reifen simuliert werden, wir werden dafür
aber in Teil 2 unsere eigenen Funktionen schreiben.
function VehicleBeginEvent(vehicleConst)
{
}
var p;
p = 0;
function VehicleEndEvent(vehicleConst)
{
}
var p;
p = 0;
Legen Sie noch eine weitere Funktion unter diesen beiden an und dann haben Sie es für’s Erste
fast geschafft. Diese Funktion definiert Verhalten und Einstellungen der Reifen, sie sollte also nicht
ganz uninteressant für Sie sein.
function VehicleTireEvent(vehicleConst, tyreIndex)
{
var steer;
var omega;
var torque;
var resistance;
steer = NewtonGetTyreSteerParam (vehicleConst, tyreIndex);
steer = steer + (my.carSteerTorque - steer) * 0.25;
NewtonSetTyreSteerParam (vehicleConst, tyreIndex, steer);
// reibung der reifen auf dem boden, je niedriger desto rutschiger
NewtonSetTyreLateralFrictionCoef (vehicleConst, tyreIndex, 1);
NewtonSetTyreLongituFrictionCoef (vehicleConst, tyreIndex, 1);
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │19

torque = my.carEngineTorque;
if (torque != 0)
{
resistance = my.car_maxToque * NewtonGetTyreRadius (vehicleConst, tyreIndex) /
my.car_topSpeed;
}
}
else
{
}
resistance = 0.15 * NewtonGetTyreInertia (vehicleConst, tyreIndex);
omega = NewtonGetTyreOmega (vehicleConst, tyreIndex);
torque = torque - resistance * omega;
NewtonSetTyreTorque (vehicleConst, tyreIndex, torque);
Und nun noch eine letzte Funktion. Mit dieser legen Sie die Schwerkraft Ihres Wagens fest.
Wenn Sie einen Blick in die newtonScript2.wdl werfen und nach der Funktion
ApplyGravityForceEvent(body) suchen, werden Sie schnell merken, dass
NewtonBodyAddForce(body, force_x, force_y, force_z) dafür verantwortlich ist. Durch Verändern
der Werte und etwas Skripten könnten Sie Ihren Ferrari z.Bsp. einfach in einen schwebenden
Raketenwagen umfunktionieren.
function VehicleForceEvent(body)
{
}
ApplyGravityForceEvent(body);
NewtonSetBodyAutoActiveState (body, 0);
Na also, so viel war es doch gar nicht. Überlegen Sie nur wieviel Zeilen Code das NGD-Team
schreiben musste damit Sie es so einfach haben. Und sollten Sie die ein oder andere Rechnung
nicht verstanden haben, ist das auch nicht weiter schlimm. Die entscheidenden Einstellungen des
Fahrzeugs und dessen Reifen werden gleich bequem in WED gesetzt. Speichern!
Fahrzeugteile in WED ausrichten
Hände von der Tastatur und WED geöffnet, jetzt wird mit der Maus gearbeitet!
Laden Sie meinen vorgefertigten Raum (newton01.wmp) und fügen Sie die Karosserie des F360 in
WED ein, Object -> Add Model, im Ordner models\ das Modell aut_f360.mdl. Platzieren Sie die
Karosserie an einer gewünschten Stelle innerhalb des Raumes.
Bevor Sie die Reifen hinzuladen noch ein Hinweis. Der Mittelpunkt der Reifen sollte genau im
Zentrum liegen, ansonsten eiert es während der Fahrt. Kontrollieren Sie daher vorerst in MED, ob
die Reifen an der richtigen Stelle sitzen und korrigieren Sie dies, wenn nötig.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │20

Wenn alles sitzt, laden Sie jetzt noch das Reifenmodell rue_360_d.mdl, duplizieren es dreimal und
platzieren die vier Reifen, wie auf dem Screenshot zu sehen, um die Karosserie. Dabei ist es
gewollt, dass die Reifen auf der linken Seite in die falsche Richtung zeigen, dies korrigiert NGD
automatisch.
Kleiner Tipp:
Unter File -> Preferences kann man die Werte verändern um Objekte präziser bewegen (Snap) und
drehen (Rotate Snap) zu können.
Als nächstes gruppieren wir alle fünf Teile des Fahrzeugs. Klicken Sie dazu jeweils auf einen davon
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │21

und drücken dann die Taste G. Haben Sie diesen Vorgang für alle Teile durchgeführt, drücken Sie
abschließend Strg + G. Nun sollten all Ihre Fahrzeugteile als ein Objekt vorliegen.
Wählen Sie das Fahrzeug an (es sollten alle Teile rot dargestellt werden) und wählen Sie Object ->
Scope -> Scope down bzw. klicken Sie auf das entsprechende Icon in der Menüleiste. Was Sie jetzt
vor sich haben ist ausschließlich das gruppierte Auto mit allen anwählbaren Einzelteilen. Damit
Newton aber korrekt mit dieser Karosserie-Reifen-Konstruktion umgehen kann, müssen jetzt noch
einmal alle vier Reifen zusammen gruppiert werden. Führen Sie dazu einfach nochmals den obigen
Gruppiervorgang durch, nur diesmal ohne die Karosserie.
Konfigurieren des Fahrzeugs
Nun wird es richtig interessant, denn jetzt konfigurieren wir unseren Wagen, sowie die einzelnen
Räder. Wer also schon immer mal einen Ferrari F360 tunen wollte, hat jetzt die Gelegenheit dazu.
Scopen Sie zu der Ebene, in der man die Karosserie einzeln anwählen kann, rechtsklicken Sie
darauf, wählen Properties und im aufpoppenden Dialog wählen Sie den Tab „behaviour“. Rechts
neben dem Eingabefeld für die Aktion klicken Sie auf den offenen Ordner (Choose Action) und
wählen aus der Liste Ihre vorhin erstellte Aktion „newton_F360“.
Hier können Sie nun, wie versprochen, so gut wie alles einstellen was das Herz begehrt. Noch
interessanter sind gleich die Reifeneinstellungen, wir gehen aber erstmal die wichtigsten Werte für
die Karosserie durch. Meine empfohlenen Werte stehen dabei immer in Klammern gleich hinter der
Bezeichnung.
• Mass (130) – Gibt das Gewicht der Karosserie an. Wichtiger Faktor, wenn es darum geht
mit anderen Physikobjekten zu kollidieren. Zudem liegt das Fahrzeug tiefer und schwerer
auf der Strasse, je höher dieser Wert ist.
• Linear_drag und Angular_drag (0.1) – Mit diesen Werten kann man Luftwiderstände
simulieren. Setzen Sie hier einfach überall 0.1 ein.
• Health (0) – Dieser Wert funktioniert in Verbindung mit Destructible und Spawn_children.
Je höher der Wert, desto mehr Schaden hält das Objekt stand.
• Shape_factor (0) – Schwer zu erklären und ich hoffe ich hab es richtig verstanden (immer
wird einem alles auf englisch erklärt :-/ ). Jedenfalls ist die Kollisionsbox eines Objekts vom
Volumen her natürlich größer als das Objekt selber und das Prinzip des Archimedes besagt,
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │22

dass die Schwerkraft eines Körpers auf Wasser gleich dem Gewicht des vom Körper
verdrängten Wassers ist. Nun da die Kollisionsbox größer ist als das Objekt, wird zu viel
Wasser verdrängt und das Objekt sinkt dementsprechend natürlich tiefer. Abhilfe schafft
hier der Wert shape_factor, welcher das Volumen der Kollisionsbox multipliziert und somit
verkleinert. Idealer Weise natürlich auf die Größe des Objekts. Nicht verstand? Auch nicht
weiter schlimm, Sie werden den Wert kaum brauchen.
• Car_topspeed (1500) – Ganz einfach die Höchstgeschwindigkeit des Wagens.
• Car_maxtorque (50) – Gibt an, wie schnell der Wagen beschleunigt.
• Collision_sph_box (unchecked) – Wenn aktiviert, wird eine Kugel zur Kollisionserkennung
benutzt, ansonsten eine Box.
• Start_active (checked) – Wenn aktiviert, fällt, rollt und bewegt sich dieses Objekt falls es
die Lage erfordert, ansonsten reagiert das Objekt erst auf Physik, wenn es von einem
anderen Physikobjekt getroffen wurde.
• Compound_collision (unchecked) – Bei zusammengesetzten Objekten wird jedes einzelne
Teil als Kollisionsbox verwendet. Achtung, keine Gewähr für die Richtigkeit dieser
Beschreibung!
• Destructible (unchecked) – Ist dieses Flag gesetzt, so ist das Objekt anfällig gegen
Schaden und der oben angegebene Health-Wert verringert sich bei jeder Kollision mit einem
anderen Physikobjekt.
• Spawn_children (unchecked) – Erreicht der Health-Wert 0, so wird das Objekt zerstört
und durch seine Child-Objekte ersetzt (z.Bsp. einem Wrack unseres Wagens).
Haben Sie alle Werte gesetzt, sind nun die Reifen an der Reihe. Scopen Sie bis zur untersten
Ebene, in der Sie jedes Rad einzeln anwählen können und weisen Sie jedem Rad die Aktion
„NewtonVehicleTyre“ zu.
Bevor Sie die Werte für jedes Rat setzen, lesen Sie sich erstmal deren Bedeutung durch, bei Reifen
ist es nämlich ein klein wenig komplizierter.
• Mass (2) – Wie bei der Karosserie gibt dieser Wert das Gewicht an.
• Steer_angle (hinten 0, vorne 20) – Gibt an, um wieviel Grad sich die Räder einlenken
lassen. Bei herkömmlichen Wagen sollten Sie für die Hinterreifen 0 eingeben, da diese sich
normalerweise nicht lenken lassen.
• Suspension_span (10) – Die Länge der Aufhängung.
• Suspension_dashpot (1.2) – Gibt die Stärke des Stoßdämpfers der Aufhängung an. Ist
dieser Wert zu niedrig, wird Ihr Wagen hin und her hopsen.
• Suspension_stiffness (5) – Gibt die Straffheit der Aufhängung an. Je höher der Wert,
desto härter liegt der Wagen auf der Strasse.
• Rolling_dry_friction (0.5) – Gibt an, wie stark der Wagen in der Kurve schlittert – nicht
übertreiben!
• Is_leftwheel – Muss markiert werden, wenn es sich um einen linken Reifen des Wagens
handelt.
• Is_poweredwheel – Gibt an, ob das Rad angetrieben wird oder nicht. Soweit ich weiß,
wird z.Zt. sowieso nur Allrad unterstützt, somit kann man diese Checkbox leer lassen.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │23

Nun, da Sie wissen, dass man linke Reifen definieren muss und die Hinterreifen einen
Einlenkwinkel von 0 Grad haben sollten, können Sie Ihre Werte eintragen.
Sind Sie damit fertig, schauen Sie nochmal kurz ob sich das Modell auch innerhalb des Raumes
befindet…
…, speichern und kompilieren das Level und starten es anschließend.
Wenn Ihnen keine Fehlermeldungen in den Weg kamen, sollten Sie Ihren Wagen von oben auf der
Strecke sehen und Ihn mit W-A-S-D steuern können. Zusätzlich können Sie noch mit dem
mittleren Mausrad zoomen und mit gedrückter rechter Maustaste die Kamera um das Auto
bewegen.
Zusätzliche Physikobjekte plazieren
Kurze Erklärung
NGD hat schon einige vorgefertigte Materialien, welche Gegenständen zugeordnet werden können,
um Physik zu simulieren. Da wir aber noch etwas Zeit (und sicher auch Lust haben ;) und einige
wichtige Materialeigenschaften nur per Skript gesetzt werden können, werden wir unser eigenes
Material erstellen.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │24

Öffnen Sie die newtonScript2.wdl und scrollen Sie zur Funktion NewtonSetupSystem(). In dieser
Funktion werden die verschiedenen Materialien erstellt und die Eigenschaften untereinander
definiert.
Um dies zu erklären, stelle ich kurz die Definition für die Eigenschaften zwischen Ground und Wood
Material vor.
// set material interaction propeteries (ground_material, wood_material)
NewtonMaterialSetFriction (ground_material, wood_material, 1.0, 0.7);
NewtonMaterialSetElasticity (ground_material, wood_material, 0.4);
NewtonMaterialSetDepthRecover (ground_material, wood_material, 0.2);
NewtonMaterialSetSoundEffect (ground_material, wood_material, hit);
Wie man anhand der Kommentarzeile richtig vermuten darf, wird hier festgelegt, wie Gegenstände,
welchen die Aktion NewtonWoodEntity zugewiesen wurde, sich beim Zusammenprall mit der
Levelgeometrie (ground_material) verhalten.
Würden wir hingegen diese Zeilen schreiben…
NewtonMaterialSetFriction (ice_material, wood_material, 1.0, 0.7);
NewtonMaterialSetElasticity (ice_material, wood_material, 0.4);
NewtonMaterialSetDepthRecover (ice_material, wood_material, 0.2);
NewtonMaterialSetSoundEffect (ice_material, wood_material, hit);
…würden wir definieren, wie sich Ice Material beim Zusammenprall mit dem Wood Material
verhalten soll.
Eine Liste von allen zuweisbaren Materialeigenschaften samt kurzer Erklärung und den Parametern,
finden Sie in der newton.wdl unter dem Stichpunkt „Physics material creation and interaction
funstion“.
Das erste eigene Material
Kommen wir zum abschließenden Teil dieses Workshops. Wir werden jetzt unser eigenes Material
erstellen und dies für einen Stapel herumstehender Reifen in unserem Level verwenden. Da wir alle
NGD Dateien in unseren Ordner kopiert haben, können wir diese auch bedenkenlos verändern,
ohne das dies größere Auswirkungen haben könnte.
In der newtonScript2.wdl definieren wir zunächst einen Namen für unser Material, der Ordnung
halber gleich unter den vordefinierten Namen.
// this global variable reprent handles to materials use in the level
var ground_material;
var wood_material;
var ivory_material;
var ice_material;
var water_material;
var tyre_material; // das ist der Name für unser Material
Scrollen Sie wieder runter zu der Funktion NewtonSetupSystem() und erstellen Sie Ihr Material.
// all other material needs to be created
wood_material = NewtonCreateMaterial ();
ivory_material = NewtonCreateMaterial ();
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │25

ice_material = NewtonCreateMaterial ();
water_material = NewtonCreateMaterial ();
tyre_material = NewtonCreateMaterial (); // hiermit erstellt Newton Ihr Material
Da wir bis jetzt kaum verschiedene Physikobjekte in unserem Level haben, bis auf unser Auto
natürlich, reicht es erstmal die Eigenschaften zwischen unserem Material und der Levelgeometrie
festzulegen. Schreiben Sie die folgenden Zeilen in die NewtonSetupSystem() Funktion, ich werde
deren Bedeutung gleich erklären.
NewtonMaterialSetFriction (ground_material, tyre_material, 1.0, 0.9);
NewtonMaterialSetElasticity (ground_material, tyre_material, 0.7);
NewtonMaterialSetDepthRecover (ground_material, tyre_material, 0.2);
NewtonMaterialSetSoundEffect (ice_material, wood_material, hit);
• Friction - Als erstes haben wir die Reibung angegeben (statisch und kinetisch) und da
Reifen ja nicht besonders gut rutschen (so soll es auch sein ;), hab ich hier besonders hohe
Werte genommen.
• Elasticity – Dieser Wert gibt an, wie stark die beiden Körper voneinander abprallen, wobei
er für Reifen sogar noch etwas höher sein könnte. Ein Formel1-Reifen der mitten in der
Fahrt vom Fahrzeug getrennt wird ist quasi nicht zu stoppen – glauben Sie mir!
• DepthRecover - Hier bin ich mir nicht ganz sicher. Scheinbar wird hier angegeben, wie
schnell das gegenseitige Durchdringen zweier Objekte wieder gelöst wird.
• SoundEffect – Definieren Sie eine Sound-Datei, die jedesmal abgespielt wird, wenn beide
Gegenstände aufeinander prallen.
Ihr Material ist bereits voll funktionsfähig, eine Kleinigkeit fehlt aber noch um es in WED auch
zuweisen zu können. Alle die sich etwas auskennen, haben sicherlich bemerkt, dass wir noch eine
Aktion für unser Material brauchen, also legen wir dieses gleich unter den anderen Material-
Aktionen an.
action NewtonIceEntity
{
}
NewtonCreateGravityEntity (ice_material);
// uses mass, linear_drag, angular_drag_x, angular_drag_y, angular_drag_z, health,
shape_factor, collision_groupId, collision_sph_box, start_active, compound_collision,
destructible, spawn_children;
action NewtonTyreEntity
{
}
NewtonCreateGravityEntity (tyre_material);
Das war’s schon. Der Kommentar über unserem Code ist übrigens nicht nur informativ, sondern
auch überaus praktisch, denn die Werte unseres Materials würden ohne diesen Kommentar in WED
statt Mass, Health usw. nur Skill1, Skill2 usw. heißen und das ist sehr unübersichtlich.
Schauen Sie es sich am besten gleich selber an, indem Sie nun endlich den Reifenstapel in unser
Level einbringen. Wechseln Sie zu WED, klicken Object -> Add Model und wählen aus dem Ordner
models\ das Modell rue_360_d.mdl. Fügen Sie noch drei weitere Reifenmodelle ein und platzieren
Sie diese zu einem Stapel, der irgendwo in unserem Raum auf dem Boden steht.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │26

Weisen Sie jedem dieser Reifen die Aktion NewtonTyreEntity zu – das hatten Sie vorher schon bei
der Karosserie und den Autoreifen gemacht – und ändern Sie den Wert Mass auf 20.
Wenn Sie fertig sind, dann speichern und kompilieren Sie Ihr Level und starten es anschließend.
Der Reifenstapel sollte jetzt in Ihrem Raum stehen und auf Kollision mit Ihrem Wagen reagieren.
Falls Ihnen einige Eigenschaften nicht zusagen sollten, dann wissen Sie ja wo diese geändert
werden können.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │27

Glückwunsch, die erste Hürde zum Physik-Flitzer haben Sie gemeistert und allzu schwer war es
auch nicht. Sie sind nun in der Lage, die Eigenschaften Ihres Wagens und einfachen Physikobjekten
Ihren Wünschen anzupassen und haben eine bessere Vorstellung über die Funktionsweise von
NGD.
Schlusswort
Bis zum nächsten Teil dieses Workshops können Sie noch etwas mit den Funktionen und Aktionen
von NGD herum experimentieren. z.Bsp. könnten Sie Ihren Ferrari über hügeliges Terrain steuern
oder völlig unkontrollierbar über Eis schlittern lassen. Und keine Hemmungen, was ich hier
niedergeschrieben habe kam auch nur durch experimentieren und durchstöbern der wdls zustande.
Im nächsten Teil werden Sie, wie schon zu Beginn gesagt, weiter in die Funktionen von NGD
eindringen und mit einigem Skriptaufwand coole Sachen mit Ihrem Wagen anstellen. Es wird also
ganz bestimmt nicht langweilig. Schreiben Sie mir am besten Ihre Wünsche und Anregungen per
Mail und ich werde versuchen diese dann einzubringen, somit haben auch andere etwas von Ihren
Ideen. Je nach Resonanz werde ich dann eventuell noch einen dritten Teil veröffentlichen.
Ich hoffe, es hat Ihnen Spaß gemacht und machen Sie’s gut bis zum nächsten Teil.
Ruben Aster aka Asse.
Asse_3DGS@web.de
Vielen Dank noch an Psionic für das ausgezeichnete F360 Modell. Ein Besuch der Seite lohnt sich!
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │28

Inhalt
Ein Nebeltutorial für das 3D Gamestudio
1.Das Nebelsystem des 3DGS
2.Eigene Systeme und volumetrischer Nebel
3.Specials: Materials und Dynamik
von Torsten „fogman“ Fock
Ist für Sie das Nebelsystem von 3D Gamestudio ein Rätsel? Oder haben Sie es verstanden und
wollen noch ganz andere Sachen machen? Dann dürften Sie die folgenden Zeilen interessieren...
Zu allen Kapiteln und Beispielen gibt es Beispiellevels, die das geschriebene Veranschaulichen.
Diese Beispiele können Sie zusammen mit dem Tutorial hier
herunterladen: http://home.arcor.de/braindamaged/Nebeltutorial.rar (Ca. 8.8 MB)
Und nun wünsche ich Ihnen viel Spaß beim experimentieren.
Das Nebelsystem des 3DGS
Beispiellevel: Beispiel_Teil_1
Wie fast alles im Gamestudio ist das Nebelsystem sehr modular aufgebaut. Es gibt vier
Nebelfarben, die per Skript und im WED verändert werden können. Aus diesen Nebelfarben kann
dann per Skript eine ausgewählt werden.
Schauen Sie sich ein einfaches Skript an, welches von diesen Nebelfarben gebrauch macht:
function fog_fnc()
{
}
d3d_fogcolor1.red = 100; // Nebelfarbe 1, Rotanteil
d3d_fogcolor1.green = 100; // Nebelfarbe 1, Grünanteil
d3d_fogcolor1.blue = 100; // Nebelfarbe 1, Blauanteil
fog_color = 1; // Benutze Nebelfarbe 1
Diese Funktion erzeugt einen grauen Nebel, da alle Farbanteile auf den selben Wert eingestellt
sind.
Weitere Beispiele:
d3d_fogcolor2.red = 255;
d3d_fogcolor2.green = 255;
d3d_fogcolor2.blue = 255;
Erzeugt weißen Nebel mit der Nebelfarbe 2.
d3d_fogcolor4.red = 100;
d3d_fogcolor4.green = 0;
d3d_fogcolor4.blue = 100;
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │29

Erzeugt violetten Nebel mit der Nebelfarbe 4. Mit fog_color können Sie nun zwischen diesen
Nebelfarben umschalten um zu bestimmen, welche angezeigt wird.
fog_color = 4;
Würde dementsprechend den vorher definierten, violetten Nebel darstellen. Es ist nicht unbedingt
nötig, die Nebelfarben per Skript zu setzen.
Im WED können sie diese Farben direkt bestimmen und per Skript jederzeit ändern.
Gehen Sie hierzu in die „Map-Proberties“ im „File-Menü“. Hier können Sie unter „Fog“ die
Nebelfarben direkt setzen. Im Skript wählen Sie dann nur noch per „fog_color“ welche Nebelfarbe
dargestellt werden soll.
Nun müssen Sie noch festlegen, wie dicht der Nebel sein soll. Hierfür gibt es drei Parameter:
„view.fog“, „view.fog_start“ und „view.fog_end“.
„fog_start“ beschreibt die Entfernung in Quants zum View, ab der der Nebel beginnen soll.
„fog_end“ beschreibt die Entfernung zum View, wo der Nebel endet.
Je dichter diese Werte zusammenliegen, desto dichter wird der Nebel sein.
Logisch, oder?
Schreiben Sie also...
function fog_fnc()
{
}
d3d_fogcolor1.red = 100; // Nebelfarbe 1, Rotanteil
d3d_fogcolor1.green = 100; // Nebelfarbe 1, Grünanteil
d3d_fogcolor1.blue = 100; // Nebelfarbe 1, Blauanteil
fog_color = 1; // Benutze Nebelfarbe 1
camera.fog_start = 100; // Der Nebel beginnt 100 Quants entfernt von der Kamera
camera.fog_end = 500; // Der Nebel endet 500 Quants entfernt von der Kamera
Beachten Sie das „camera“ der vordefinierte View ist. Sie können natürlich auch jeden selbst
definierten View benutzen.
Um Texturen direkt vom Nebel zu beeinflussen dient der „albedo“. Ihn können Sie im WED bei
den Texture-Settings einstellen. Werte unter fünf stehen für die Nebelfarbe, fünf selbst für
Dunkelheit. So ist es leicht möglich, Oberflächennebel zu erzeugen.
Um zu bestimmen wie stark sich Nebel auf dynamische Schatten auswirkt, benutzen Sie den
„view.fog“ Parameter.
camera.fog = 0; // Nebel wirkt sich nicht auf dynamische Schatten aus.
camera.fog = 100; // Nebel wirkt sich voll auf dynamische Schatten aus.
Und das war das ganze Geheimnis des Nebelsystems!
Wie, das reicht Ihnen nicht...?
Da muß ich mir ja was einfallen lassen...
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │30

Volumetrischer Nebel und eigene Systeme
Wir kochen unser eigenes Süppchen Bodennebel... Beispiellevel: Beispiel_Teil_2_1
Um volumetrischen Nebel zu erzeugen, welcher die Grundlage für eigene Systeme ist, müssen Sie
tricksen. Das Prinzip werde ich anhand von Bodennebel darlegen.
Dieser wirkt zusammen mit dem standard Nebelsystem äußerst atmosphärisch:
Hierfür benötigen Sie zuerst mal den normalen Nebel. Die Funktion kennen sie ja schon.
function fog_fnc()
{
}
d3d_fogcolor1.red = 100; // Nebelfarbe 1, Rotanteil
d3d_fogcolor1.green = 100; // Nebelfarbe 1, Grünanteil
d3d_fogcolor1.blue = 100; // Nebelfarbe 1, Blauanteil
fog_color = 1; // Benutze Nebelfarbe 1
camera.fog_start = 100; // Der Nebel beginnt 100 Quants entfernt von der Kamera
camera.fog_end = 500; // Der Nebel endet 500 Quants entfernt von der Kamera
Starten Sie nun MED. Erstellen Sie einen Würfel und löschen Sie alle Vertices bis auf die obersten
vier, und geben Sie der verbliebenen Fläche eine hellgraue Skin:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │31

Speichern Sie das Modell in Ihrem Projektordner und laden Sie es zwölfmal in Ihr Level. Skalieren
Sie die Modelle so, das sie in den schon erzeugten Nebel hineinragen werden, und ordnen Sie sie in
geringen Abständen übereinander an:
Eine kleine Action benötigen Ihre Modelle auch noch, um sie transparent zu machen und an die
Kamera anzuhängen.
Wie wäre es damit:
action fog_disc
{
my.transparent = on;
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │32

}
my.alpha = 10;
while(1)
{
}
my.x = camera.x;
my.y = camera.y;
wait(1);
Die Modelle werden also transparent sein, mit einem geringen Alphawert. Sonst wäre der
Bodennebel zu „dicht“. Mit der while-Schleife erzwingen Sie, das die x und y Positionen der
„Nebelplatten“ immer denen der Kamera entsprechen.
Da sich Bodennebel am Boden am wohlsten fühlt, lassen wir die z Position unberührt. Weisen Sie
den Modellen die Action zu, und Sie haben Ihren ersten eigenen, volumetrischen Nebel erzeugt!
Eigene Systeme... Beispiellevel: Beispiel_Teil_2_2
Nun können Sie sich gewiß schon denken, wie Sie ein komplett eigenes System realisieren
könnten. Ich möchte auch nicht weiter auf die Gründe eingehen, Sie werden welche haben. Viele
Wege führen auch hier nach Rom, ich möchte einen davon vorstellen.
Zuerst benötigen Sie wieder den MED oder einen anderen Modeller. Erschaffen Sie dort bitte einen
einfachen Zylinder und löschen alle Vertices bis auf die untersten. Geben Sie auch dieser Fläche die
graue Skin:
Nun ziehen Sie den mittleren Vertex nach oben – etwa so:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │33

Speichern Sie das Modell und öffnen Sie Ihr Level in WED. Fügen Sie das Modell wieder zwölfmal
ein – je öfter umso feiner wird Ihr Nebel aufgelöst sein. Übertreiben Sie es aber nicht!
Hier sehen Sie die eingefügten Modelle. Ich habe jedes folgende etwas größer skaliert:
Kommen wir zur dazugehörigen Action:
action fog_disc_2
{
my.transparent = on;
my.alpha = 10;
while(1)
{
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │34

}
}
my.x = camera.x;
my.y = camera.y;
wait(1);
Nein, Sie haben sich nicht verlesen. Es ist genau die gleiche Action die ich für den Bodennebel
verwendet habe, bis auf ihren Namen. Wenn gewünscht, kann die z – Position natürlich auch noch
an die Kamera gehängt werden.
Es ist nur ein Weg, Modelle zu benutzen. Ebenso geht es mit Map Entities oder Sprites ja selbst
Terrain könnten Sie mißbrauchen. Ich habe mich für Modelle entschieden, da diese schnell
gerendert werden und man viele weitergehende Sachen mit ihnen anstellen kann. Was halten Sie
zum Beispiel von ein paar Materialien und waberndem Nebel?
Sehen Sie – ich auch...
Specials: Material und Dynamik
Wunderliche Waschküchen... Beispiellevel: Beispiel_Teil_3
Anhand eines „Nebelsees“ werde ich Ihnen eine Möglichkeit zeigen, dynamischen Nebel zu
erzeugen.
Zu diesem Zweck benötigen Sie ein einfaches Terrain mit einer Vertiefung. Für eben diese
Vertiefung müssen Sie ein Modell erstellen. Beginnen Sie also wieder mit dem MED:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │35

Ich habe einfach das Terrain in ein Modell gewandelt (im Edit-Menü), und alle Vertices gelöscht bis
auf die Vertiefung. Diese habe ich dann mit dem Scale -Tool zu einer planen Fläche gemacht und
ihr die graue Skin gegeben. In WED müssen Sie dieses Modell nun über der Vertiefung im Terrain
platzieren. Laden Sie das Modell dreimal in den WED und verschieben Sie sie etwas
gegeneinander:
Um eine schönere Gesamtatmosphäre zu erzeugen, laden Sie bitte auch noch das Bodennebel –
Modell zwölfmal in den Leveleditor. Ordnen Sie die Flächen so an, wie in Kapitel 2 beschrieben:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │36

Lassen Sie uns dem Nebel Leben einhauchen. Dazu brauchen wir etwas C-Script. Fügen Sie die
folgenden, schon bekannten Funktionen ein um Bodennebel und normalen Nebel zu erhalten:
function fog_fnc()
{
}
d3d_fogcolor1.red = 100; // Nebelfarbe 1, Rotanteil
d3d_fogcolor1.green = 100; // Nebelfarbe 1, Grünanteil
d3d_fogcolor1.blue = 100; // Nebelfarbe 1, Blauanteil
fog_color = 1; // Benutze Nebelfarbe 1
camera.fog_start = 100; // Der Nebel beginnt 100 Quants entfernt von der Kamera
camera.fog_end = 500; // Der Nebel endet 500 Quants entfernt von der Kamera
action fog_disc
{
}
my.transparent = on;
my.alpha = 10;
while(1)
{
}
my.x = camera.x;
my.y = camera.y;
wait(1);
Weisen Sie bitte den zwölf Bodennebel Modellen die Action „fog_disc“ zu. Und vergessen Sie nicht,
die Funktion „fog_function( )“ zu starten!
Nun wird es ein wenig komplizierter. Sie haben sich bestimmt schon Gedanken gemacht, wie man
die drei Flächen für den Nebelsee wabern läßt. Da gäbe es die Möglichkeit die Flächen im MED zu
animieren. Aus verschiedenen Gründen habe ich mich für eine andere Art der Animation
entschieden.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │37

Animierte Modelle würden auf Dauer langweilig aussehen, brauchen mehr Speicher und sind
langsamer in der Berechnung. Lassen Sie uns also eine Action schreiben, die direkt auf die Vertices
der Modelle wirkt, auch „Meshdeforming“ genannt.
Vor dieser Funktion graut es mir am meisten, da sie sich auf Sinusberechnung stützt.
Frisch ans Werk, ich werde Ihnen jede Zeile erklären:
var counter;
var index;
var vertices = 241;
var vertex_array[241];
Diese vier Zeilen definieren drei Variablen und einen Array. Ein Modell für den Nebelsee hat 241
Vertices. Daher dieser Eintrag.
action fog_dynamic
{
my.transparent = on;
my.passable = on;
my.alpha = 15;
while (counter < vertices) // Solange Counterwert kleiner Verticeswert
{
den Array
Temp
vertex_array[counter] = random(360); // Setze Zufallswerte von 0-360 in
counter += 1; // Zähle den Arrayindex um eins hoch
while (1)
{
den Z - Eintrag
Vektor
}
}
while (index < vertices) // Solange Indexwert kleiner Verticeswert
{
}
vec_for_mesh(temp, my, index); // Aktuelle Vertexposition in
temp.z = sin(counter + vertex_array[index]) * 1; // Ändere
vec_to_mesh(temp, my, index); // Bewege den Vertice mit dem
index += 1; // Zähle eins auf den Index
counter += 0.2 * time; // Zähle den Counter hoch
index = 0; // Setze index auf null
wait(1);
Was für ein Monster! Keine Angst, Sie werden sehen, es ist durchaus einfach zu verstehen.
Die ersten drei Zeilen sollten selbsterklärend sein. Das Modell wird transparent und passabel
gemacht, der Alphawert der Transparenz beträgt 15.
Als nächstes folgt eine Schleife, die solange durchlaufen wird, bis die Variable „counter“ einen Wert
von 241 hat. Jener Wert der in der Variable „vertices“ steht. In dieser Schleife werden nun alle 241
Einträge des Arrays mit Zufallszahlen von 0 – 360 gefüllt. Auf den „Counter“ wird jeweils eins
hinzuaddiert, so das die Schleife nach dem 241. Lauf endet. Aufgrund der Abbruchbedingung
können wir in der Schleife auf ein „wait“ verzichten. Es kann keine Endlosschleife entstehen.
In der nächsten Zeile beginnt eine solche „Endlosschleife“. Und in ihr noch eine Schleife. Man nennt
so etwas „verschachtelt“. Es wird also permanent („endlos“) geprüft, ob sich die Bedingung erfüllt
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │38

und die zweite Schleife aktiv wird. Da der die Variable „index“ null ist und in der Schleife wieder
um eins hochgezählt wird, wird sie 241 mal durchlaufen.
Der Befehl „vec_for_mesh“ liest die Vertexposition des Vertices der durch den „index“ ausgewählt
wurde und kopiert sie in den vordefinierten Vektor „temp“. Die Z-Komponente des Vektors wir nun
in einer Sinusfunktion verändert, abhängig vom Wert des „counters“ und dem aktuellen
„Winkeleintrag“ (0-360) in dem Array.
Per „vec_to_mesh“ wird die Vektorposition dem per index ausgewähltem Vertice wieder
„aufgezwungen“ - er bewegt sich auf der Z-Achse. Natürlich muß der „index“ dann wieder um eins
hochgezählt werden, um den nächsten Vertex zu bedienen. Wenn alle Vertices ein Stückchen
bewegt wurden, wird die Schleife verlassen. Der Counterwert wird erhöht, um die Vertices beim
nächsten Durchlauf weiterzubewegen. Die Variable „index“ wird auf null gesetzt – das Spiel beginnt
von vorne.
Spielen Sie ein wenig mit der Action – sie eignet sich auch als Grundstock für Gardinen, Wasser
und was sonst noch so „wabert oder wellt“
Weisen Sie diese Action den „Nebelseemodellen“ zu. Nun haben Sie ihren ersten dynamischen
Nebel erzeugt. Lassen Sie uns noch rasch ein Material für den Nebel definieren. Sie werden
überrascht von den Effekten sein, die wie Wasser oder Toxien wirken können.
Schauen wir uns seine Definition an:
material fog_mat
{
}
ambient_red = 10;
ambient_green =10;
ambient_blue = 10;
diffuse_red = 0;
diffuse_green = 100;
diffuse_blue = 0;
specular_red = 0;
specular_green = 255;
specular_blue = 0;
emissive_red = 0;
emissive_green = 100;
emissive_blue = 0;
power = 5;
Die Grundhelligkeit (Ambient) beträgt 10.
Diffuse beschreibt, wieviel Licht und welche Farbe das Material empfangen kann.
Specular setzt einen Glanzpunkt
Emissive bestimmt mit welchem Wert sich die Entity illuminiert.
Power steht für die Größe des Glanzpunktes.
Schreiben Sie in die Action „fog_dynamic folgendes, gleich unter „my.passable = on;“ :
my.material = fog_mat;
Nun haben Sie dem Nebelsee ein Material zugewiesen. Was noch fehlt ist ein dynamisches Licht,
um die Auswirkungen des Effekts richtig zu sehen.
Sie können ein einfaches Modell nehmen (z. B. einen Würfel) und diesem die folgende Action
geben:
action light_dyn
{
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │39

}
my.invisible = on;
my.lightrange = 300;
my.red = 255;
my.green = 255;
my.blue = 255;
Platzieren Sie Ihre „Sonne“ dicht über dem Nebelsee, builden Sie und starten Sie Ihren Rundgang
durch ein radioaktives Medium.
Nun sind wir am Ende des Tutorials angelangt. Ich hoffe ich konnte Ihnen einige Inspiration über
den kreativen Umgang mit Dunst verschaffen.
Versuchen Sie, das Material zur Laufzeit zu beeinflussen, indem Sie seine Parameter in einer
Funktion verändern, ändern Sie die Skin, oder, oder, oder...
Lassen Sie es mich wissen, wenn Sie einen neuen Effekt ausgetüftelt haben und verlaufen Sie sich
nicht. Sonst muß ich auch noch ein Nebelhorntutorial schreiben.
In diesem Sinne – Rauchen Sie ab!
Torsten „fogman“ Fock
fogman@gmx.com
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │40

Modelldesign - Teil 1: Mesh eines Tischs mit Blender
Einleitung
von Josef/Jupp
Hallo ich bin Josef Brandl und dürfte Ihnen als Josef oder Jupp aus dem 3DGS-User Forum bekannt
sein. In dieser Reihe werde ich zeigen, wie man professionelle Modelle mit Blender erstellt. Warum
mit Blender und nicht MED? In MED wird sich einiges mit dem nächsten Update ändern, außerdem
kommen Fortgeschrittene schnell an die Grenzen MEDs. In Blender gibt es weitaus mehr Features.
Es ist fast unmöglich alle zu kennen, allein das Handbuch erfasst 686 Seiten. Ein weiterer guter
Grund ist, dass Blender opensource ist, das heißt nicht nur, dass es laufend Updates gibt sondern
auch, dass sich jeder das Programm kostenlos aus dem Internet runterladen kann. Ich hoffe, dass
ich dem einen oder anderen mit diesem Tutorial einen Gefallen tue.
Viel Spaß beim Lesen
Josef
Der Start: Was wird benötigt?
Wir brauchen für diesen Part nur den Open Source Modeller Blender. Sie bekommen die aktuelle
Version bei www.blender3d.org .
Die Tischplatte
Zu allererst öffnen wir das Programm, wir sehen den Standardwürfel. Die rosa Linie um ihn herum
bedeutet, dass er selektiert wurde. Ich habe ihnen eine Auflistung über die Funktionen der Maus
zusammengestellt. Prägen sie sich diese gut ein, dann können wir loslegen.
Info: Die Funktionen der Maus
Linke Maustaste – Ist in Blender fast nur für das Drücken der Buttons zuständig. Außerdem lassen
sich damit Arbeitsschritte abschließen (wie z.B. eine Verschiebung oder Skalierung) und
Mausgesten zeichnen. Ich habe drei Gesten herausgefunden: 1) Malt man eine gerade Linie, so
aktiviert man das Verschiebewerkzeug 2) Malt man einen Kreis, so aktiviert man das
Rotationswerkzeug 3) Malt man ein "V", so aktiviert man das Skalierungswerkzeug. Nach längerer
Arbeit mir Blender kann ich allerdings sagen, dass es viel einfacher ist, wenn man die Hotkeys auf
der Tastatur her nimmt.
Mittlere Maustaste – Diese Taste wurde bei neuen Mäusen durch ein drückbares Mausrad ersetzt.
Mit dieser Taste lässt sich u. a. die Ansicht des 3D Ports, auf dem Sie sich gerade mit dem Cursor
befinden, rotieren. Sie werden dabei feststellen, dass es entscheidend ist, wo sie gerade Ihren
Cursor auf dem 3D Port haben. Denn ist die Position weiter außen, so rollt die Kamera, ist die
Position mehr nahe der Mitte, so schaut man sich um. Probieren sie das gleich mal aus. Ich zeige
im Anschluss, wie sie die Kamera wieder zu Ursprungsposition zurückbringen. Wenn Sie zusätzlich
shift drücken, dann können Sie die Ansicht verschieben .Drücken Sie zusätzlich strg, dann zoomen
Sie, allerdings wenn sie ein Mausrad haben, dann nehmen Sie doch das dafür her.
Rechte Maustaste – Es lassen sich damit einzelne Vertices/Edges/Faces/Objectes selektieren,
drücken Sie shift um eine Auswahl damit zu erweitern. Auch können Sie den aktuellen Schritt
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │41

damit abbrechen, z.B. eine Verschiebung.
Genug der Theorie. Lasst uns weiterarbeiten. Der schon vorhandene Würfel ist für einen Tisch
genau das Richtige, darum können wir direkt anfangen ihn zu editieren. Oder anders: Wir wechseln
in den Editiermodus. Das machen wir entweder mit der Tabulator Taste oder wählen in dem Header
des Views den "Editmode" aus.
Drücken Sie im Anschluss die A-Taste, um alles zu de-selektieren.
Info: Die A-Taste
• Diese Taste macht falls es Selektiertes gibt alles un-selektiert, falls nicht wird einfach alles
selektiert.
• Wechseln Sie in die Oben-Ansicht, per Druck auf die 7 des Nummerblocks.
Info: Der Nummernblock
• 0 – Die Ansicht der Kamera
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │42

• 1 – Die x,z Ansicht (von vorne)
• 1 + strg – Die -x,z Ansicht (von hinten)
• 2 – Die Kamera nach unten drehen
• 3 – Die y,z Ansicht (von rechts)
• 3 + strg – Die -y,z Ansicht (von links)
• 4 – Die Kamera nach links drehen
• 5 – Umschalter zwischen perspektivischer und orthographischer Ansicht. Bei der
perspektivischen Ansicht werden anders wie bei der orthographischen Ansicht die Objekte je
weiter sie weg sind kleiner.
• 6 – Die Kamera nach rechts drehen
• 7 – Die x,y Ansicht (von oben)
• 7 + strg – Die -x,y Ansicht (von unten)
• 8 - Die Kamera nach oben drehen
Anmerkung:
Dies wirkt sich auf die 3D View aus über der sich die Maus gerade befindet.
Sie sehen nun alles von Oben. Ein Druck B-Taste aktiviert das Werkzeug für ein Auswahlrechteck,
das funktioniert so etwa wie in MED oder in Malprogrammen, wie Gimp und Paint. Wir selektieren
damit die Vertices einer Seite unseres Tisches. Die selektierten Vertices werden nun gelb.
Info: Die Bedeutung der Farben im Edit Mode
selektiert unselektiert
Vertices hellgelb violett
Edges dunkelgelb schwarz
Faces rosa blau
Wenn Sie die Kamera ein wenig bewegen, dann sehen Sie, dass wir nicht erreicht haben, was wir
eigentlich wollten. Wir haben nicht alle Vertices auf der Seite selektieren können. Woran das wohl
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │43

liegt?
Die Antwort ist eigentlich ganz einfach: Die Auswahl ist standardmäßig auf Sichtbares limitiert.
Schalten Sie den hier rot eingezeichneten Button aus und wiederholen sie dann die Prozedur mit
der Box (B-Taste).
Wir sehen, dass jetzt alle 4 Vertices selektiert sind. Nun stellen Sie sicher, dass Sie in der Top
Ansicht sind (7). Drücken Sie die E-Taste für eine Extrusion. Wir wählen Region. Bewegen Sie die
Maus. Sie sehen jetzt die neuen Faces die entstanden sind. (Folgendes ist für später wichtig) Die
eigentliche Extrusion ist abgeschlossen! Sie befinden sich nur noch im Verschiebe-Modus, d.h.,
wenn Sie die rechte Maustaste drücken um die Aktion abzubrechen, sind die neu entstandenen
Faces immer noch vorhanden. Sie müssen zusätzlich noch die Kombination aus strg+z-Taste
drücken um auch die Extrusion rückgängig zu machen. Mit einem Druck von strg bewegen wir
unsere Selektion am Raster. Wir verschieben das Ganze nur um ein Kästchen. Per Druck der linken
Maustaste bestätigen Sie. Machen Sie das auch mit der anderen Seite unseres zukünftigen Tischs.
Das Resultat:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │44

Jetzt kommt wieder das Auswahlviereck dran. Selektieren Sie die Vertices an der linken und
rechten Kante. Nicht vergessen: Dieses Tool fügt die neuen Vertices immer zur bestehenden
Auswahl hinzu, d.h. sie brauchen keine zusätzliche Taste drücken, um die Auswahl zu vergrößern.
Wir wollen nun diese Ecken reinskalieren, sodass der Tisch nachher abgerundete Kanten hat.
Drücken Sie es um die selektierte Auswahl zu skalieren. Drücken Sie danach y um die Vertices
entlang der y-Achse zu skalieren. In welche Richtung welche Achse geht sehen sie unten links im
3D Port. Halten Sie dann noch strg gedrückt um am Raster zu skalieren. Per Druck der linken
Maustaste bestätigen sie die Aktion.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │45

Wechseln wir nun in die Frontansicht (1) Drücken Sie die A-Taste um alle Vertices zu selektieren.
Nun drücken sie „S“ um wieder zu skalieren. Wir wollen unseren Tisch nun auf eine normale dicke
bringen. Wählen sie mit einem druck der z Taste die z Achse aus und skalieren die platte nun
ungefähr so dick wie auf folgendem Bild:
In der Top Ansicht machen wir jetzt den Tisch noch etwas länglicher, indem wir jeweils die Vertices
oben und unten ein wenig nach innen verschieben. Sie können dazu dieses Verschiebewerkzeug
mit den Pfeilen hernehmen. Wenn sie es nicht haben, dann stellen sie sicher, dass diese Buttons
des View-Headers, siehe Bild, gedrückt sind: Sie wollen nicht immer dieses Werkzeug hernehmen?
Sie können auch G für Grab drücken. Letztlich ist es egal wie sie ihre Auswahl verschieben.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │46

Das Untergestell
Jeder Tisch hat direkt unter der Platte ein paar Streben. Da wir die grundlegenden Funktionen jetzt
besprochen haben werde ich das jetzt kürzer fassen.
Vergewissern sie sich, dass sie in der Top-Ansicht sind und rufen durch Drücken der Leertaste ein
Menü auf. Wählen sie Add >> Plane. Nun haben wir ein flache Platte erstellt. Drücken sie E >>
Region für eine Extrusion. Drücken sie Esc und dann S zum reinskalieren. Ihr Ergebnis dürfte in
etwa so aussehen:
Also was haben wir gemacht. Wir haben aus einer flachen Platte durch Extrusion Faces rundherum
erstellt, da die sich aber in der Höhe nicht unterscheiden sollen brachen wir die Verschiebung ab.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │47

Richtig: Das würde auch mit der rechten Maustaste gehen.
Nun wechseln wir in den Face Select Mode. Sie dachten sich höchstwahrscheinlich schon, dass
Blender, ähnlich zu med oder wings auch verschiedene Selektionsmodi hat. Den Selektionsmodus
können sie bequem in View-Header auswählen:
Lasst uns die großen Faces des Planes auswählen, denn die müssen weg. Klicken sie dazu mit der
rechten Maustaste auf den mittleren Punkt, drücken sie entf >>> faces
Den zweiten mittleren Punkt löschen sie auch noch, so bleibt ein Ring übrig. Bei diesem Ring
verwenden wir jetzt eine Extrusion um ihn wie ein Untergestell aussehen zu lassen.
Jetzt müssen wir diesen Ring nur noch verschieben und vielleicht etwas rumskalieren, damit er so
wie in diesem Bild unter der Tischplatte sitzt.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │48

Die Tischbeine
Ein jeder Tisch hat Beine, aber da gibt es auch unterschiedliche, auf jeden Fall verstehe ich zum
Beispiel unter einem Tischbein keinen viereckigen Klotz.
Wir fangen diesmal wieder mit einem Würfel an. Sie wissen jetzt ja wie man neue Formen
hinzufügt und diese bearbeitet, also erstellen sie so einen Cube und Modellieren daraus ein
Tischbein.
Sie können sich entweder an meiner Form orientieren oder eine ganz neue Kreation schaffen.
Bewegen sie den Cursor über das Tischbein und drücken sie die L-Taste. Blender selektiert es so
automatisch. Was macht Blender da genau? Antwort: Er sucht sich den zum Mauscursor
nächstgelegenen Vertex und selektiert ihn und all seine mit ihm verbundenen Vertices.
Wir duplizieren nun einfach das Bein per shift+d. Drücken sie x um es nur entlang der x-Achse zu
verschieben. Bestätigen sie mit Enter/linke Maustaste.
Jetzt müssen wir das neue Bein noch spiegeln, das ist durch eine Skalierung möglich. Drücken sie
S um das Bein zu skalieren und wieder x für die x-Achse, nun geben sie -1 mit dem Nummernblock
ein. Drücken sie Enter zum bestätigen. Verschieben sie es nun noch zur Richtigen Stelle.
Die gleiche Prozedur jetzt mit den beiden nun erstellten Beinen in der Seitenansicht.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │49

Schluss
Und fertig ist der Tisch… nein nicht ganz, aber das können sie auf diesem Bild jetzt nicht sehen.
Die Normalen der Faces der Beine sind durch das Spiegeln auf der falschen Seite. Sichtbar können
sie das machen, indem sie unten bei den Buttons im mesh-fenster den „double sided“-Button
abwählen. Jetzt sehen sie es auch, dass manche faces viel dunkler sind als andere. Im
Objektmodus sehen sie die dunklen gar nicht. Drücken sie strg+n um dies zu beheben. Blender
kalkuliert nun die Normalen neu.
Fertig ist der Tischmesh. In der nächsten Ausgabe werde ich erklären, wie man dieses Mesh
"beskinnt". In einem weiteren Teil wird noch dran kommen, wie man das Modell nach MED
exportiert.
Bei Fragen und Anregungen kontaktiert mich im Gamestudio Forum. Meinen Nickname kennt ihr ja.
Ich wünsche noch viel Spaß mit Blender. Bis zur nächsten Ausgabe!
"happy blending!"
Josef/Jupp
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │50

Laser - und Photonentorpedoeffekte
von tuschcarsten
Hallo und herzlich Willkommen zum Waffeneffekt-Artikel des 3DGS Magazins.
Ich wurde schon oft gefragt, wie man Laser-oder Torpedoeffekte macht. Hier die Lösung:
Laserstrahl
Der Strahl soll so aussehen, wenn er fertig ist:
Als erstes machen wir das Modell für den Laserstrahl.
Dazu öffnen wir MED, fügen einen Würfel ein und löschen alle Seiten bis auf eine:
Dann gehen wir in den Polygon-Modus (links oben) und markieren alles. Dann auf [Edit]->[copy
selected] klicken, dann auf paste. Wir gehen wieder in den Vertex-Modus und markieren wieder
alles. Dann auf den [Merge] Button (oben rechts) klicken. Das bewirkt, dass die Faces jetzt
beidseitig ausgerichtet sind.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │51

Jetzt geben wir dem Modell einen Skin und klicken dazu auf [view]->[Skin].
dann ändern wir die Größe des Skins: [Edit]->[resize skin] und geben die Werte 128x32 ein.
Jetzt stellen wir sicher, dass im normalen Editor (nicht im Skin-Editor) alle Faces markiert sind und
klicken im Skin Editor auf [Edit]->[create md2 mapping] und wählen die Option [TOP] aus.
Das gleiche machen wir noch einmal mit der Option [Bottom].
Dann Ziehen wir die Vertices so zurecht, dass die Faces die Skin-map voll ausfüllen.
Dann exportieren wir das ganze als bmp.
Um die soeben gespeicherte Datei zu bearbeiten, öffnen wir sie in Paint. Als erstes muss alles
schwarz gemalt werden (wenn es das nicht schon ist). Dann speichern wir die Datei mit [Speichern
unter..] als 24-Bit Bitmap ab (ACHTUNG: nicht mit 256 Farben).
Dann malen wir einen dicken farbigen strich von links nach rechts durch die Bitmap. Danach noch
einen kleineren weißen Strich in den ersten Strich hinein:
Jetzt das ganze noch mit einem Bildbearbeitungsprogramm wie Photoshop, Photo Express, Gimp
oder Photo Impression schön unscharf machen und fertig ist die Skin-map.
Jetzt müssen wir sie nur noch im Skin Editor von MED importieren:
[View]->[Skins]
[File]->[import skin image].
Jetzt wird der Skin-Editor geschlossen und nochmal gemodelt:
Wir markieren alle vertices und kopieren sie wie oben schon beschrieben. Dann drehen wir sie um
90°, bis sie so aussehen:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │52

Und dann immer so weiter, bis es so aussieht:
{
}
my.bright = on; //scheint hell
my.ambient = 100; //100% Helligkeit
my.unlit = on; //reagiert nicht auf externes Licht und Schatten
my.overlay = on; //kein Schwarz
my.flare = on; //transparent
my.green = 50; //lichtwerte....
my.blue = 200;
my.lightrange = 50;
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │53

Photonentorpedos
Die Photonentorpedos funktionieren in etwa genauso:
Wir öffnen wieder MED und fügen einen Würfel ein.
Wir löschen alle Flächen, bis auf eine, kopieren diese und kehren die Normals um(wie beim
Laserstrahl). Dann markieren wir alle Faces (im Face_mode) und öffnen den Skin Editor.
Dann ändern wir die Größe des Skins: [Edit]->[resize skin] und geben z.B. die Werte 84x81 ein.
Jetzt klicken wir auf [Edit]->[create md2 mapping] und wählen die Option [TOP] aus. Das gleiche
machen wir noch einmal mit der Option [Bottom].
Dann Ziehen wir die Vertices so zurecht, dass die Faces die Skin-map voll ausfüllen.
Dann exportieren wir das ganze als bmp.
Diese Bmp öffnen wir dann mit Paint und malen ein paar rote und orange Striche von der Mitte aus
nach außen. Dann öffnen wir ein anderes Bildbearbeitungsprogramm wie Photoshop o.a. und
verwischen das Ganze. Die Bmp sollte nun etwa so aussehen:
Jetzt müssen wir sie nur noch im Skin Editor von MED importieren:
[View]->[Skins]
[File]->[import skin image].
Jetzt wird der Skin-Editor geschlossen und nochmal gemodelt:
Wir markieren alle vertices und kopieren sie wie oben schon beschrieben. Dann drehen wir sie um
90°, das selbe wiederholen wir solange, bis es so aussieht:
Dann noch das Modell speichern und diese Aktion zuweisen:
action torpedo
{
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │54

}
my.bright = on; //scheint hell
my.ambient = 100; //100% Helligkeit
my.unlit = on; //reagiert nicht auf externes Licht und Schatten
my.overlay = on; //kein Schwarz
my.flare = on; //transparent
my.green = 50; //lichtwerte....
my.red = 200;
my.lightrange = 50;
mfg
euer tuschcarsten
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │55

Bit-Operatoren
von mk.1
Neben den bekannten Rechenoperatoren wie das bekannte Addieren, Subtrahieren, Multiplizieren
und Dividieren gibt es eine Reihe weiterer Operatoren: Die Bit-Operatoren.
Durch ist es erst möglich, Rechenmaschinen wie die heutigen Home-PCs zu konstruieren. Obwohl
sehr primitiv sind sie sehr häufig von großem Nutzen. Es gibt eine Vielzahl von Bit-Operatoren. Die
bekanntesten sind "und", "oder" und "nicht".
Wie funktionieren Bit-Operatoren?
Um mit Bit-Operatoren zu arbeiten, müssen Sie zuallererst wissen, was ein Bit ist.
Das Wort "Bit" ist eine Abkürzung für "binary digit" (eng.: Binärziffer). Während eine Dezimalziffer
(in unserem Dezimalsystem) zehn Zustände haben kann die Zahlen null bis neun), kann ein Bit
nur den Zustand 1 oder 0 annehmen. Je nach Verwendung spricht man auch von true (wahr) und
false (falsch) oder Signal und kein Signal.
Bit-Operatoren funktionieren wie andere Operatoren auch. Zwei Inputs ergeben ein Output. Hier
ein Beispiel für die Addition:
Ein Bit-Operator funktioniert genauso – zwei Inputs, ein Output.
Bit-Operator "und"
In C-Script (sowie den allen anderen neueren Programmiersprachen) wird das Kaufmanns-Und "&"
für den AND-Operator verwendet. Der Output ist immer dann true (1), wenn beide Inputs true (1)
sind:
Die folgende Tabelle zeigt alle möglichen Kombinationen:
0
1
0
1
&
0
0
1
1
=
0
0
0
1
Bit-Operator "oder"
Dieser Operator hat immer dann den Output true, wenn mindestens einer der Inputs true ist:
0
1
0
1
&
0
0
1
1
=
0
1
1
1
Dieser Operator wird durch einen geraden Strich "|" dargestellt.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │56

Das Binärsystem
Das heutige weltweite System ist das Dezimalsystem, welches die 10 Ziffern 0-9 kennt. Neben
unserem System gibt es unendlich viele andere, wie das Hexadezimale System (16 Ziffern), das
Oktalsystem (8 Ziffern), das Binärsystem (2 Ziffern). Die Babyloner verwendeten sogar ein System
mit 60 verschiedenen Ziffern.
Da ein Computer nur zwei Zustände kennt (Signal/kein Signal), ist das Binärsystem das sinnvollste
System zum Rechnen. Wenn Sie an die erste Grundschule zurückdenken, erinnern Sie sich
vielleicht an die "Einer, Zehner, Hunderter". Sie waren Ausdrücke für eine weitere "Stelle" im
System. Die Zahlen null bis neun benötigen, nur eine Stelle, die Zahlen 10 bis 99 zwei Stellen und
so weiter. Das bedeutet, dass Sie, sobald alle Ziffern verwendet wurden, eine neue Stelle
brauchen. Dieses Problem tritt auch im Binärsystem auf, da es nur zwei Ziffern gibt, die Null und
die Eins. Wenn Sie die Zwei darstellen wollen, benötigen Sie bereits zwei Ziffern.
Dezimal Binär
0 0
1 1
2 10
3 11
4 100
5 101
6 110
Um eine Zahl aus dem Binärsystem in das Dezimalsystem umzurechnen, bedarf es einiger
Denkarbeit. Im Binärsytem wird immer dann eine neue Stelle verwendet, wenn alle anderen
Stellen nicht mehr ausreichen, um eine Zahl darzustellen. Mit einer Stelle können Sie nur die
Zahlen Null und Eins darstellen, mit zwei Stellen bereits die Zahlen Null bis Drei. Mit drei Stellen
sind bereits die Zahlen Null bis Sieben darstellbar. Zur Umrechnung geben Sie jeder Stelle einen
Umrechnungswert. Diese zusammengerechnet ergeben den Dezimalwert. Die erste Stelle hat
dabei den Umrechnungswert 1, die zweite den Wert 2, die dritte den Wert 4 und die vierte den
Wert 8 und so weiter. Es ist leicht erkennbar, dass hier immer das doppelte des vorigen Wertes
eine Rolle spielt. Die fünfte Stelle würde also den Wert 16 haben. Anders ausgedrückt sind die
Umrechnungswerte Zweierpotenzen:
2 0 = 1
2 1 = 2
2 2 = 4
2 3 = 8
Angenommen, Sie müssten die folgende Binärzahl 1101 in das Dezimalsystem umrechnen, dann
sollten Sie wie gefolgt vorgehen:
Die Zahl besteht aus vier Stellen, deren Wert 8,4,2,1 ist. In diesem Fall ist der Wert 2 nicht
vorhanden. Zusammengerechnet wird also 8, 4 und 1. Das Ergebnis wäre also 13.
1 1 0 1 Binär
2 3 2 2
0 2 0
Umrechnungswert
8 4 0 0 Dezimalwert
Ein weiteres Beispiel für die folgende Zahl 1011:
Die Werte 8, 2 und 1 sind in der Binärzahl enthalten. Die Dezimalzahl wäre demnach 11.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │57

Variablen als Flags
Entities haben bekanntlich nur 8 Flags, was häufig nicht ausreicht. In dem Fall verwenden viele
Anfänger Skills als Flags, indem sie diese auf den Wert 0 oder 1 setzen. Für acht Flags würden auf
diese Weise bereits acht Skills benötigt werden. Das ist Verschwendung, denn bereits ein Skill
reicht für acht Flags aus. Möglich wird das durch Bitoperatoren und dem Wissen über das
Binärsystem. Im Grunde stellt jede Stelle im Binärsystem ein Flag dar, da sie auf 0 oder 1 gesetzt
werden kann. Die Engine selbst macht sich dies beim move_ und trace_mode zunutze, denn im
Grunde sind die beiden "modes" einfach nur Variablen.
Das Setzen von Flags funktioniert sehr einfach. Da jedes Flag eine "Stelle" repräsentiert, müssen
Sie einfach nur den Umrechnungswert dieser Stelle in die Variable einfügen.
Flag1 entspricht 1
Flag2 entspricht 2
Flag3 entspricht 4
...
Der Hintergrund ist einfach, dass jeder Kombination dieser Zahlen einmalig ist und eine Zahl
niemals doppelt auftritt. In den mode-Beispielen werden diese Flags/Zahlen einfach addiert.
Das ist aber nicht ungefährlich. Angenommen, Sie hätten Flag1 aktiviert, dann wäre die Variable
(ich nenne sie "var") var == 1. Sie benutzen var später nochmal und wollen das Flag1 setzen,
wissen aber nicht, ob es bereits gesetzt ist. Mit var += 1 wäre nun var == 2. Das Ergebnis wäre,
dass Flag2 gesetzt ist, Flag1 aber nicht (denn Flag2 entspricht bereits dem Wert Zwei). Sie können
dies nachprüfen, indem Sie trace_mode = ignore_me + ignore_me setzen. Das Ergebnis wird sein,
dass me nicht ignoriert wird, dafür aber you.
Die richtige Art, ein Flag zu setzen, ist der "oder"-Operator. Im folgenden Beispiel ist Flag4, Flag3
und Flag1 gesetzt. Flag3 wird nun auf on gesetzt. Das Ergebnis bleibt gleich:
Input1
Input2
or- result
1
0
1
1 0 1
1 0 0
1 0 1
Es ist also sicherer, wenn Sie den trace_mode mittels or-Operator setzen:
trace_mode = ignore_me | ignore_you | ignore_push;
Hier ist ein Codebeispiel, mit dem sie für eine Variable var ein bestimmtes Flag setzen können.
function SetFlag(var, flag_num) {
if(flag_num == 1) { var |= 1; } // setze Flag1
if(flag_num == 2) { var |= 2; } // setze Flag2
if(flag_num == 3) { var |= 4; } // setze Flag3
if(flag_num == 4) { var |= 8; } // setze Flag4
if(flag_num == 5) { var |= 16; } // setze Flag5
if(flag_num == 6) { var |= 32; } // setze Flag6
if(flag_num == 7) { var |= 64; } // setze Flag7
if(flag_num == 8) { var |= 128; } // setze Flag8
}
Nachdem Sie nun wissen, wie Flags gesetzt werden, sollten Sie wissen, wie Sie überprüfen
können, ob ein Flag gesetzt ist. Dazu verwenden Sie den und-Operator. Er liefert wie bereits
erläutert nur eine 1 für eine Stelle zurück, wenn beide Inputs an dieser Stelle eine 1 haben. In
folgendem Beispiel ist wieder Flag4, Flag3 und Flag1 gesetzt und es soll überprüft werden, ob
Flag3 gesetzt ist:
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │58

Input1
Input2
und result
1
0
0
1 0 1
1 0 0
1 0 0
Das Ergebnis ist also genau der Umrechnungswert des zu prüfenden Flags, falls das Flag gesetzt
ist. Hier ist der Code zum Prüfen eines Flags:
function IfFlag(var, flag_num) {
}
if(flag_num == 1) {
}
if((var & 1) == 1) { return(1); } // Flag1 ist gesetzt
if(flag_num == 2) {
}
if((var & 2) == 2) { return(1); } // Flag2 ist gesetzt
if(flag_num == 3) {
}
if((var & 4) == 4) { return(1); } // Flag3 ist gesetzt
if(flag_num == 4) {
}
if((var & 8) == 8) { return(1); } // Flag4 ist gesetzt
if(flag_num == 5) {
}
if((var & 16) == 16) { return(1); } // Flag5 ist gesetzt
if(flag_num == 6) {
}
if((var & 32) == 32) { return(1); } // Flag6 ist gesetzt
if(flag_num == 7) {
}
if((var & 64) == 64) { return(1); } // Flag7 ist gesetzt
if(flag_num == 8) {
}
if((var & 128) == 128) { return(1); } // Flag8 ist gesetzt
return(0); // Flag ist nicht gesetzt
Ist das Flag gesetzt, gibt die Funktion eine 1 (true zurück), andernfalls eine 0 (false). Die
Anwendung ist simpel:
if(IfFlag(trace_mode,1)) {
}
error("Flag1 der Variable trace_mode ist gesetzt");
Was nun noch fehlt, ist das entfernen eines Flags. Dazu benötigen sie einen weiteren Bit-Operator,
den "Inversen-Operator", oder auch COMPLEMENT operator. Er wird durch ein Tilde (~)
dargestellt. Er invertiert die Bits einer Variable, sodass aus 0 eine 1 und aus 1 eine 0 wird.
Für das Beispiel der Dezimalzahl 5:
var 0 1 0 1
~var 1 0 1 0
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │59

Man könnte sagen, dass alle aktivierten Flags deaktiviert werden und alle anderen aktiviert. Was
nützt Ihnen das, um ein bestimmtes Flag zu deaktivieren? Betrachten Sie folgende Formel:
var &= ~1
In Worten ausgedrückt: Benutze den und-Operator auf die Bit-Inverse von 1.
1 0 0 0 1
~1 1 1 1 0
Hier ist eine beliebige Variable und die Bit-Inverse von 1, die mit dem AND-Operator benutzt
werden:
var 1 1 0 1
~1 1 1 1 0
and-result 1 1 0 0
Das Ergebnis ist tatsächlich, dass das Flag verschwindet. Hier ist der Code:
function RemovFlag(var, flag_num) {
}
if(flag_num == 1) { var &= ~1; } // entfernt Flag1
if(flag_num == 2) { var &= ~2; } // entfernt Flag2
if(flag_num == 3) { var &= ~4; } // entfernt Flag3
if(flag_num == 4) { var &= ~8; } // entfernt Flag4
if(flag_num == 5) { var &= ~16; } // entfernt Flag5
if(flag_num == 6) { var &= ~32; } // entfernt Flag6
if(flag_num == 7) { var &= ~64; } // entfernt Flag7
if(flag_num == 8) { var &= ~128; } // entfernt Flag8
Zu guter letzt...
Es gibt natürlich noch andere Bit-Operatoren wie z.B. XOR – exclusive or – und Kombinationen
von Bitoperatoren. Die genannten reichen aber erstmal aus. Auch die Funktionen sind sehr
unschön geschrieben und könnten ein Stück gekürzt werden. Zum Verständnis sind sie meiner
Meinung nach aber ausreichend bzw. besser geeignet. Wenn Sie ein wenig mit Bitoperatoren
gearbeitet haben, können Sie Zeilen auch direkt eingeben ohne eine große Funktion zu benutzen.
Hier nochmal einige Kurzbeispiele:
var |= 4; // setzt Flag3
var &= ~8; // entfernt Flag4
if(var & 8) { // Flag4 ist gesetzt
}
return(1);
Noch einfacher ist es, wenn Sie die Umrechnungswerte durch Definitionen ersetzen:
define flag_1, 1;
define flag_2, 2;
define flag_3, 4;
define flag_4, 8;
define flag_5, 16;
var |= flag_2; // setzt Flag2
var &= ~flag_3; // entfernt Flag3
if(var & flag_1) { // Flag1 ist gesetzt
return(1);
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │60

}
Ich hoffe, diese Einführung in Bit-Operatoren war verständlich. Kritik und Lob bitte an das 3DGS-
Magazin oder direkt an mk.1@gmx.net
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │61

Möglichkeiten des Physiksystems in Gamestudio
Commercial
Dies ist kein Tutorial.
Vielmehr soll dieser Artikel dazu anregen sich mit dem „beschränkten“ Physiksystem der
Commercial Version zu beschäftigen, was alles andere als langweilig ist.
Viele „träumen“ wohl von der Professional Version, da wäre es doch gut zu wissen, was man von
der Gamestudiophysik so zu erwarten hat.
Vielen ist auch nicht bewußt was man mit einem Physikobjekt alles anstellen kann. Abgesehen
von diversen Spielereien mit Kugeln eignet sich die limitierte Physik für Gleiter, Schiffe, Schlitten
und Bob´s, kurz, alles was gleitet. Man denke an Wintersportarten. Aber auch fiese Fallen und
Kanonenschüsse, Interaktion mit Objekten und Constraints sind möglich. Wegwerfbare
Gegenstände und eine Gravitygun sind ebenso machbar. Geduldsspiele in der Art eines
Kugellabyrinthes, Ballspiele, von Fußball über Golf bis Tennis. In einem Physikobjekt steckt mehr
als man meinen könnte.
Zuerst sollte man betrachten was man mit einem Objekt alles bekommt und welche Eigenschaften
ein Physikobjekt auszeichnen:
• Gravitation
• Ein Schwerpunkt
• Polygongenaue Kollisionserkennung wenn gewünscht
• Events werden nach wie vor ausgelöst
• Es können Kräfte verschiedenster Arten auf das Objekt angewendet werden
• Mehrere Physikobjekte können simuliert werden, allerdings auf Kosten der Performance
• Es kann Beschränkungen (Constraints) mit der „Welt“ geben.
Was kann man nun damit anfangen? Auf ein Physikobjekt können Kräfte ausgeübt werden,
sogenannte Beschleunigungen. Wenn man diese an Events koppelt, können nette
Interaktionsmöglichkeiten herauskommen. Ein Trampolin oder ähnliches müsste z.B. bei Kontakt
eine Kraft auf das Physikobjekt anwenden. Schauen Sie sich dazu eine Skizze an:
Die Kugel ist das Physikobjekt. Sie kommt von links oben im Bogen
angeflogen und trifft auf die „Trampolin“ Entity. Diese erkennt aufgrund eines
Events die Kollision und wendet per „phent_addcentralforce“ eine Kraft in Z-
Richtung (nach oben) auf das Physikobjekt an. Das Resultat ist eine
physikalisch korrekte Bewegung der Kugel, da sie ihre „Eigenrichtung“ von
rechts nach links beibehält. Die Kraft in Z-Richtung wird nur addiert.
Es ist etwas gewöhnungsbedürftig Physikobjekte über Kräfte und nicht über „ent_move“ oder
„c_move“ zu bewegen. Wenn Sie jedoch einmal ein wenig herum experimentiert haben, werden Sie
das System schnell verstehen. Was sie zuerst verstehen müssen ist der Unterschied zwischen
lokalen und globalen Kräften. Globale Kräfte beziehen sich immer auf das Level und seine
Koordinaten. Hiermit können Sie zum Beispiel eine Drift erzeugen, die als Gegenwind wirkt. Lokale
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │62

Kräfte beziehen sich auf die Koordinaten der Entity und sind z.B. für Flugsimulationen recht
hilfreich. So muß man sich nie Gedanken über die Ausrichtung der Entity zu den Levelkoordinaten
machen.
Was bieten uns nun Constraints in einer solch limitierten Umgebung? Zur Anregung wieder eine
Skizze:
Die mittlere „Platte“ ist mit einer Beschränkung zur Welt verbunden. Hier
wäre es „ph_hinge“. Wenn nun der Player auf die Plattform geht, sorgt ein
Event dafür das die Plattform sich bewegt, z.B. durch „phcon_setmotor“. Es
sind auch noch ganz andere Gemeinheiten möglich - denken Sie an Indiana
Jones und die dicke Steinkugel die ihm nachstellt, Pendel und Messer die von
der Decke hängen oder noch labilere Plattformen. Die Arten der möglichen
Beschränkungen sind vielfältig.
Ich selbst habe noch nicht viel Erfahrung mit der Physikengine gesammelt, kann jedoch sagen
dass sie sehr intuitiv ist. Sie werden sehen, es macht Spaß Kräfte auf Objekte auszuüben und die
Auswirkungen zu erfahren. Danach können Sie versuchen mit Constraints zu arbeiten.
Ich hoffe ich konnte Ihnen ein wenig den Mund wässrig machen. Physik in Spielen bietet großartige
Möglichkeiten, und wenn es nur ein Objekt zur selben Zeit ist. Ein Tutorial zum Thema wird noch
folgen.
Grüße,
Quellen zum Thema:
• Aum 25 - Physik Demo
• Aum 37 - Mehrere Physikobjekte mit Commercial
• Aum 47 – Rollem, ein Marble Klon
• Link: http://www.conitec.net/english/gstudio/aum.htm
- Physikengine Forumthread –
Glossar:
B
Torsten „fogman“ Fock fogman@gmx.com
Link: http://www.coniserver.net/ubbthreads/postlist.php?Cat=0&Board=UBB32
Im folgenden werden die im Text hervorgehobenen Begriffe genauer erläutert.
Beschleunigung --> Kräfte
Beschränkungen --> Constrains
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │63

C
E
G
K
P
Constraints
Einfach gesagt sind Constraints Gelenke, welche die Bewegungen der Objekte einschränken. Es
gibt Scharniere (ph_hinge), Kugelgelenke (ph_ball), Schubverbindungen (ph_slider) und
Radachsen (ph_wheel).
Events
Wenn eine Kollision stattfindet können sogenannte Events ausgelöst werden. Die solcherart
gestartete Funktion kann nun z.B. mit Kräften auf das Objekt wirken.
Gravitation
Die Schwerkraft / Gewichtskraft. Hier bietet sich ein Zitat aus dem Gamestudiomanual an: „Die
Erdanziehungskraft ist normalerweise 9.81 m/s², 1 Quant ist normalerweise als 1 Zoll = 2.54cm
definiert. Um die Erdanziehungskraft zu simulieren, muss vecGravity.z bei Standardscalierung auf
(-9.81 * 100 / 2.54) = -386 gesetzt werden.“
Gravitygun
Eine immer wieder gern gestellte Frage ist, ob dies denn mit GS möglich sei. Natürlich muß ich da
sagen, es wird etwas Arbeit sein, aber warum sollte es nicht funktionieren Eine Gravitygun bewegt
Objekte (Möbel, Autos, Gegner), also wirkt sie mit Kräften auf andere Objekte. Genau das, was
eine Physikengine kann ;)
Kollision
Aneinanderstoßen einer Entities mit anderen Objekten.
Kollisionserkennung
Die Gamestudiophysik hat den großen Vorteil der polygongenauen Kollisionserkennung.
Da diese sehr rechenaufwändig ist, gibt es noch andere Kollisionshüllen. Kugel-,
Quader- und Zylinderform sind möglich.
Kollisionshülle
Die Hülle um das Physikobjekt welche bestimmt ab wann eine Berührung als Kollision zählt.
Kräfte lokal / global
Kräfte sind z.B. lineare Beschleunigung und Drehmomente. Lokale Kräfte beziehen sich auf die
Koordinaten des Objekts, globale Kräfte beziehen sich auf die Levelkoordinaten.
Polygongenaue Kollisionserkennung --> Kollisionserkennung
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │64

S
W
Schwerpunkt
Der Schwerpunkt beschreibt den „Nullpunkt“ eines Objektes. Wenn Sie das Objekt an ihm
aufhängen würden, könnten Sie es in jede Richtung drehen ohne das es sich in seine alte Position
zurückbewegt. Man bezeichnet diesen Zustand auch als „indifferent“, im Gegensatz zu „labil“
(kopflastig, z. B. wenn man einen Stock auf einem Finger balanciert) und „stabil“ (wenn der Stock
wie ein Pendel hängt). Ein Stehaufmännchen hat einen sehr niedrigen Schwerpunkt, es ist unten
schwerer als oben. Ein Fernsehturm hat einen hohen Schwerpunkt, er ist oben schwerer als unten.
In der Gamestudiophysik ist immer der Mittelpunkt einer Entity der Schwerpunkt. (Nicht sein Origin
/ Nullpunkt in MED/WED !)
Welt
Etwas unglücklich gewählt, beschreibt dieser Begriff die Umgebung, also das Level. Wenn Objekte
also eine Beschränkung mit der „Welt“ eingehen, so ist das als ob sie ein Scharnier in eine Straße
betonieren – die Straße wird sich nicht bewegen, wohl aber das Teil welches Sie am anderen Ende
des Scharniers befestigen.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │65

Inhalt:
Formationsanordnungen in einem 3D Spiel
von Dieter Meier aka ARAS14
• Vorbereitung des Levels und des Mainskriptes
• Änderung des Mainskriptes
• Kamera in der "camera.wdl"
• Funktion "move_view()"
• Bewegung der Führungsfigur in der "Bewegungs.wdl"
• Funktion "get_target()"
• Funktion "gravity_entity()"
• Funktion "move_entity()"
• Funktion "chef_player_move()"
• Aktion "haupt_player"
• Formation der Entity´s in der "Formation.wdl"
• Aktion "entitys"
• Funktion "entity_formation"
• Funktion "pos1_ent"
Für die unter Ihnen die zu wenig Zeit haben selbst ein Level für das Tutorial zu bauen, habe ich das
Ganze schon vorbereitet. Sie finden unter der unten genannten URL.Adr. ein Beispiellevel mit den
dazugehörigen Skripten. Ich wünsche Ihnen viel Spaß dabei.
http://space01.annih.de/DemoFormation.zip
Einführung:
Ich möchte in diesem ersten Tutorial auf die Grundzüge einer Formationsanordung und deren
Bewegung eingehen. Desweiteren werden wir eine isometrische Kamera programmieren und das
Skript für eine Playerbewegung mit Hilfe des Cursors realisieren.
Solche Formations Anordnungen werden hauptsächlich in Strategiespielen Anwendung finden. Es
gibt bestimmt noch anderen Möglichkeiten so etwas zu realisieren. Ich möchte Ihnen eine davon
vorstellen.
Vorbereitung des Levels und des Mainskriptes
Bauen Sie ein Level nach Ihren Wünschen oder verwenden Sie das mitgelieferte, das ich für Sie
schon vorbereitet habe. Generieren Sie von Ihrem Level ein Mainskript. Wenn Sie das Demolevel
verwenden brauchen Sie sich diese Arbeit nicht mehr machen, da ich für Sie das Skript schon
vorbereitet habe.
Änderung des Mainscriptes
Öffnen Sie das Mainskript Ihres Levels und entfernen Sie die Include Dateien nach der
"particle.wdl" Datei. Oder klammern Sie diese wie im unteren Beispiel einfach aus. Diese Dateien
benötigen wir für unsere Formationsanordungen nicht. Die ganzen Änderungen im Mainskript
beziehen sich noch auf die alten Templates. Bei Verwendung der Neuen müssen Sie das Skript
dementsprechend anpassen.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │66

// The INCLUDE keyword can be used to include further WDL files,
// like those in the TEMPLATE subdirectory, with prefabricated actions
include ;
include ;
include ; // must be inserted before doors and weapons
include ; // remove when you need no particles
/*
include ; // remove when you need no doors
include ; // remove when you need no actors
include ; // remove when you need no weapons
include ; // remove when you need no fighting
//include ; // include when doing an adventure
include ; // remove when you need no lens flares
*/
Was Sie noch ausklammern müssen wenn Sie ein neues Skript von Ihrem Level generiert haben
sind die Anweisung "lensflare_start();" und "move_view_cap = 1;". Suchen Sie nach folgenden
Zeilen und klammern Sie diese aus.
// initialize lens flares when edition supports flares
ifdef CAPS_FLARE;
endif;
//lensflare_start();
// use the new 3rd person camera
//move_view_cap = 1;
Schreiben Sie ans Ende der Funktion "main()" noch den Befehl "mouse_toggle();", damit der
Cursor sofort nach Laden des Levels sichtbar wird.
// client_move(); // for a possible multiplayer game
// call further functions here...
mouse_toggle();
}
Als nächstes includieren Sie bitte die zwei Dateien "Bewegung.wdl" und "Formation.wdl". Diese
zwei Dateien werden später unsere Skripte, wie der Name schon sagt, für die Formation und die
Bewegung enthalten.
Sollten Sie die beigestellten Skripte verwenden, müssen Sie im Skript "DemoFormation.wdl"
unbedingt den Verweis auf den Template-Ordner hier:
path "D:\\PROGRAMME\\GSTUDIO6\\template"; auf den Path Ihres Template Ordners
umschreiben.
Kamera in der "camera.wdl"
Die Kamera sollte uns sowohl einen Einblick über das ganze Szenario, als auch eine detailierte
Ansicht bieten, was bedeutet sie sollte auf jeden Fall zoombar sein. Die Veränderung des
Drehwinkels (Pan-Winkel) und des Schwenkwinkels (Tilt-Winkel) sollten wir auch nicht vergessen
um später unsere Einheiten nicht aus den Augen zu verlieren. Die Zoom-, Dreh- und
Schwenkbewegungen der Kamera werden wir im nächsten Tutorial programmieren und ausführlich
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │67

esprechen. In diesem hier werden wir uns mit einer einfachen festen Kamera begnügen. Legen
Sie nun eine WDL-Datei an und nennen sie"camera.wdl". Sie beinhaltet die Steuerung der Kamera.
Beginnen wir mit den Variablen für die Kamera die man benötigt.
var camera_pan = 0; // Winkel der Kamera
var camera_dist = 250; // Abstand zum Player
var camera_z_pos = 800; // Höhe der Kamera
Damit hätten wir schon alle Variablen die wir für die "camera.wdl" benötigen. Was auch noch sehr
hilfreich ist, wäre die Definition aller Funktionen die im dazugehörigen Skript vorkommen. Ich
bevorzuge dies immer, um zu vermeiden das eine Funktion aufgerufen wird, die vorher noch nicht
deklariert worden ist und gehe so einer Engine Fehlermeldung, die daraufhin bestimmt kommen
wird aus dem Weg. Demzufolge schreiben wir nach den Variablen die Definition der Funktionen. In
diesem Fall haben wir nur eine Funktion zum Definieren.
function move_view();
Funktion "move_view()"
Beginnen wir nun mit der Funktion "move_view()". Es umfaßt die eigentlich Bewegung der Kamera.
function move_view()
{
zugehörigen
}
camera.genius = player; // Entity wird unsichtbar wenn die Kamera die
// Grenzen berührt
// Berechnung X-Koord. Kamera
camera.x = player.x + (camera_dist * sin(camera_pan));
// Berechnung Y-Kood. Kamera
camera.y = player.y + (camera_dist * cos(camera_pan));
camera.z = player.z + camera_z_pos; // Berechnung Höhe der Kamera
vec_diff(temp,player.x, camera.x);
vec_to_angle (temp,temp);
camera.pan = temp.pan; // Kamera Pan-Wert
camera.tilt = temp.tilt; // Kamera Tilt-Wert
Die erste Zeile der Funktion bewirkt das der Player unsichtbar wird sobald die Kamera die Grenzen
der Entity berührt. Was in unserem Fall aber nicht auftreten wird. Zeile Zwei und Drei geben die
Berechnung der x- und y-Koordinaten der Kamera bezogen auf die Weltkoordinaten an. Ich will
hier nicht weiter auf diese Winkelberechnungen eingehen, da es hier den Rahmen wohl sprengen
würde. Hierzu gibt es auf der Website von Grimber ein sehr ausführliches Tutorial von "Evelyn
Boo". Nur soviel sei gesagt das wir mit den Angaben in der Klammer "(camera_dist *
sin(camera_pan))" die x-Koordinate unserer Kameradistanz berechnen und mit der Anderen die y-
Koordinate. Die dritte Zeile beinhaltet die Berechnung der Kamerahöhe. In den darauffolgenden
Zeilen wird einmal der Vektor von der Kamera zum Player berechnet und mit "vec_to_angle" der
Winkel dieses Vektors bestimmt. Danach werden die Pan- und Tilt-Winkelder Kamera danach
ausgerichtet. So das erste Skript wäre nun vollendet. Wenden wir uns nun schwierigeren Dingen
zu.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │68

Bewegung der Führungsfigur in der "Bewegungs.wdl"
Öffnen Sie eine weitere WDL-Datei und geben Sie ihr den Namen "Bewegung.wdl". Diese Datei
beinhaltet alle Funktionen die sich mit der Bewegung der Führungsfigur, in diesem Fall der Player-
Entity, befassen.Sollten Ihnen die Funktionen "chef_player_move" bekannt vorkommen ist das
durchaus möglich. Sie bezieht sich im Großen und Ganzen auf das sehr gute diablo-Script aus
einem Aum-Heft. Sie wurde von mir überarbeitet und angepaßt. Beginnen wir wieder mit den
benötigten Variablen.
//// Variablen
var vecfrom;
var vecto;
var my_target;
var ziel_pos;
var force;
var friction;
var dist[3];
var abs_dist[3];
//// Definitionen der Skill´s
define _force, skill36;
define _vz_entity,skill45; // Geschwindigkeit vertikal der Entity
define _v_entity,skill47; // Geschwindigkeit horizontal der Entity
define ziel,skill48; // Freigabe Zielposition 0 = Aus, 1 = An
Als nächstes rufen wir wieder alle Funktionen auf um eine etwaige Fehlermeldung zu umgehen.
function get_target();
function gravity_entity();
function move_entity();
function chef_player_move();
Funktion "get_target()"
Jetzt beginnen wir mit dem ersten Skript. Es wird die Funktion "get_target()" sein. Mit deren Hilfe
wir dem Player durch Anklicken im Level ein Ziel zuweisen.
function get_target() // Zielposition
{
vecfrom.x = mouse_pos.x; // X-Position des Cursors
vecfrom.y = mouse_pos.y; // Y-Position des Cursors
vecfrom.z = 10;
vec_set(vecto,vecfrom);
vec_for_screen(vecfrom,camera); // Vektor bekommt Bildschirmkoordinaten
vecto.z = 5000;
vec_for_screen(vecto,camera); // Vektor bekommt Bildschirmkoordinaten
trace(vecfrom,vecto); // trace von der Kamera auf angeklickten Punkt
vec_set(my_target,target);
vec_set(ziel_pos,target);
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │69

vec_sub(ziel_pos,player.x); // Bestimmung des Richtungsvektors
vec_to_angle(player.pan,ziel_pos); // Drehung der Playerentity in Richtung der
Zielpos.
}
player.tilt = 0;
player.ziel = 1; // Spieler hat Zielposition zugewiesen
Zeile 1-7 beziehen sich auf die Berechnung der x- und y-Position des Cursors und Umrechnung
dieser Koordinaten mit Hilfe des "vec_for_screen" Befehls in einen Vektor. Diese Vektoren
benötigen wir um mit dem "trace" Befehl von einem gedachten Punkt, direkt hinter dem Bildschirm
hinein ins Level zutracen und zwar 5000 Quants hinter den Bildschirm. Der Schnittpunkt mit der
Levelgeometrie wird im "target" Vektor gespeichert und gibt uns somit unseren Zielpunkt an.
Danach bestimmen wir den Richtungsvektor von der Playerposition zur Zielposition mit "vec_sub"
und anschließend drehen wir noch den Player in Richtung der Zielposition mit Hilfe des Befehls
"vec_to_angle".
Funktion "gravity_entity()"
Folgt nun eine Funktion die verhindert das eine Entity aus irgendwelchen unvorhersehbaren
Gründen in der Luft schwebt ohne herunter zufallen. Die "gravity_entity" Funktion.
function gravity_entity()
{
vec_set (temp.x,nullvector);
vec_set(temp,my.x);
temp.z -=4000;
trace_mode = ignore_me + ignore_sprites + use_box + ignore_models;
result = trace(my.x,temp); // Trace auf den Boden
if (result > 5)
{
}
else
{
}
force.z = -5; // Schwerkraft
friction = 0.1;//Reibung
force.z = -0.5 * result; // Boden-Elastizität
friction = 0.5; // Bodenreibung
my._vz_entity = time * force.z + max(1-time * friction,0) * my._vz_entity; //
Geschw. vert.
}
abs_dist.z = time * my._vz_entity; // Distanz vertikal
Die erste Zeile verwenden wir dazu um den Vektor "temp" zu löschen, also alle Werte auf Null zu
setzen. Danach überschreiben wir den Vektor mit den Koordinaten der Entity. Nachdem wir der
"temp.z" Variablen einen Wert 4000 Quants unter der Entity zugewiesen haben, führen wir einen
"trace" von der EntityPosition zu einem Punkt 4000 Quants darunter durch. Stößt der Trace auf ein
Hindernis wird diese Entfernung in der Variablen "result" gespeichert und dient uns somit zur
weiteren Berechnung. Ist das Ergebnis der Result-Variablen größer als 5 Quants setzen wir die
Schwerkraft auf den Wert -5 und die Reibung, da wir uns ja folglich in der Luft befinden, auf einen
sehr niedrigen Wert hier 0.1. Sollte das Gegenteil der Fall sein und unser "result" ist kleiner als 5
oder hat gar einen negativen Wert, was bedeuten würde, daß die Entity schon in den Boden
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │70

eingedrungen ist, kommt unsere Formel "force.z = -0.5 * result" zum Einsatz. Sollte das Ergebnis
unserer Messung negativ sein wird mit dieser Formel der "force.z" Wert, also die Bewegung
vertikal, wieder auf einen positiven Wert gebracht, da ja "Minus * Minus" bekanntlich "Plus" ist.
Das bedeutet unsere Entity macht wieder eine Bewegung noch Oben aus dem Boden heraus . Die
letzten Zeilen bewirken einen stetigen Anstieg dieser Geschwindigkeit und deren Berechnung der
vertikalen Distanz der Entity.
Funktion "move_entity()"
Bewegungsfunktion um Entity mit Hilfe des relativen- und absoluten Vectors zu bewegen.
function move_entity()
{
my._v_entity = time * force.x + max(1-time*0.7,0) * my._v_entity;
//Geschwindigkeit vor.
}
dist.x = time * my._v_entity; //Distanz vorwärts
dist.y = 0;
dist.z = 0;
move_mode = ignore_passable + glide;
result = ent_move(dist,abs_dist); // Bewege den Player
Die ersten beiden Zeilen beziehen sich auf die vorwärts Bewegung der Entity, bezogen auf ihren
"force.x"Wert. Hierfür benötigen wir nur die Variable "dist.x" da wir mit der Entity nur eine relative
Bewegung ausführen, bezogen auf die Richtungswinkel der Entity. Somit kann man die Werte
"dist.y" und "dist.z"auf Null setzen. Danach geben wir noch den "move_mode" an und bewegen
dann die Entity mit "ent_move".
Funktion "chef_player_move()"
In dieser Funktion finden wir die "vec_dist" Berechnung zum Zielpunkt und die Aktivierung der
Funktionen "gravity_entity" und "move_entity".
function chef_player_move()
{
while(1)
{
}
if(player.ziel == 1) // Player hat eine Zielposition
{
// Nur Bewegung wenn Distanz zum Ziel größer 35 Quants ist
while(vec_dist(player.x,my_target.x) > 35)
{
force = my._force * 12; // Geschwindigkeitsberechnung des Player´s
// Vorzeitiger Abbruch der Bewegung beim drücken der rechten Maustaste
}
if(mouse_right == 1){wait(1);player.ziel = 0;break;}
gravity_entity(); // Sprung zur Gravitationsfunktion der Entity
move_entity(); // Sprung zur Bewegungsfunktion der Entity
wait(1);
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │71

}
wait(1);
}
Diese Funktion wird stetig ausgeführt. Danach wird mit "if(player == 1)" überprüft ob der Player
eine Zielposition hat. In diesem Fall wird eine zweite Schleife gestartet, die testet ob der Player
mehr als 35 Quants vom Zielpunkt entfernt ist. Trifft dies zu wird die Geschwindigkeit des Players
gesetzt und die Funktionen "gravity_entity" und "move_entity" ausgeführt. Mit Hilfe der Zeile
"if(mouse_right == 1)" wird der Zielbefehl durch drücken der rechten Maustaste wieder
abgebrochen. Sollte die Entfernung weniger als 35 Quants betragen wird die Schleife beendet und
erst wieder gestartet wenn der Abstand zwischen Ziel und Player größer geworden ist.
Aktion "haupt_player"
Diese Aktion teilen wir in WED unserer Entity zu. Sie wird unseren Player darstellen. Alle anderen
Entities der Formation werden sich um diese Entity sammeln und ihr folgen.
action haupt_player
{
}
player = me;
my._force = 1; // Grundgeschwindigkeit des Players
chef_player_move();
while(1)
{
}
move_view(); // Aktivierung der Kamerafunktion
wait(1);
Als Erstes weisen wir dem "me"-Pointer den "player"-Pointer zu. Jetzt können wir diesen Pointer in
allen anderen Funktionen verwenden, ohne eine "Empty Pointer" Fehlermeldung zu bekommen.
Danach geben wir der Entity eine Grundgeschwindigkeit mit "my._force = 1" und starten
anschließend unsere "chef_player_move()" Funktion. Es wird noch eine Schleife gestartet in der wir
die Kamerafunktion aufrufen. Damit stellen wir sicher das uns die Kamera auch folgt, da diese
Funktion immer durchlaufen wird. Wie Sie bestimmt schon bemerkt haben wird unsere
"get_target" Funktion noch nirgends aufgerufen. Sie soll ja nur beim Drücken der linken Maustaste
aktiviert werden, darum realisieren wir das Ganze mit einem einfachen Befehl.
// Linke Maustaste aktiviert die Zielposition für den Player
On_mouse_left get_target;
So damit hätten wir schon die ersten Teile unseres Tutorials geschafft, lassen Sie uns jetzt zum
eigentlichen Hauptteil kommen. Die Skripte für die Entities die unserem Player in einer Formation
folgen sollen.
Formation der Entities in der "Formation.wdl"
Was brauchen wir dazu? Einmal natürlich Entities die sich immer in der gleichen Formation hinter
dem Player sammeln. Wir benötigen also bestimmte Fix-Punkte die wir am Anfang festlegen. Das
Ganze realisieren wir über ein Array aus dem wir diese Parameter auslesen. Diese Parameter
werden immer unsere Zielposition sein. Um diese Position festzulegen benötigen wir noch eine
Hilfsentity,in der wir diese Parameter speichern und die sich immer mit dem Player bewegt. Auf
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │72

diese Weise können wir später der Hilfsentity diverse Formationen vorgeben. Nun brauchen wir nur
noch unsere Folgeentity, ich nenne sie einmal unseren Soldaten. Unser Soldat richtet sich nach der
Hilfsentity aus und läuft auf sie zu. Nun wollen wir das Ganze einmal in ein hoffentlich lauffähiges
Skript umwandeln.Beginnen wir wieder mit unseren Variablen und Definitionen.
//// Target MDL
string mace_mdl = ; // Hilfsentity
//// Variablen
var i; // Array Index
var position[8] = -100,-100,-100,100,-200,-200,-200,200; // Array
//// Definitionen der Skill´s
define x_pos,skill30; // x_pos der Hilfsentity
define y_pos,skill31; // y_pos der Hilfsentity
define z_pos,skill32; // z_pos der Hilfsentity
define pos_target,skill36; // Zielposition für Soldaten
//// Funktionen
Aktion "entitys"
function entity_formation(); // Steuerung des Soldaten
function pos1_ent(); // Steuerung der Hilfsentity
Als Erstes beginnen wir mit der Aktion "entitys", hier wird die Funktion der Soldaten aufgerufen. Es
bedarf wohl nicht mehr Erklärung.
action entitys
{
}
my.entity_force = 15; // Festlegung der Geschwindigkeit
entity_formation(); // Aufruf der Funktion
Funktion "entity_formation"
Nun das Skript für die Steuerung des Soldaten. Ich werde Ihnen zuerst das Skript vorstellen und
Ihnen anschließend die Erklärung für einzelne Befehle des Skriptes liefern.
function entity_formation()
{
while(player == null){wait(1);} // Erst weiter wenn Player erstellt ist
my.x_pos = player.x + position[i]; // x_pos der Hilfsentity
i += 1;
my.y_pos = player.y + position[i]; // y_pos der Hilfsentity
i += 1;
you = ent_create(mace_mdl,my.x_pos,pos1_ent); // Hilfsenetity
my.skill40 = handle (you); // you-Pointer abspeichern
while (1)
{
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │73

}
you = ptr_for_handle(my.skill40); // you-Pointer zurück holen
vec_set(temp,you.x);
trace_mode = ignore_models + ignore_sprites + ignore_passents + use_box;
trace(my.x,temp); // Trace zur Hilfsentity
vec_set(my.pos_target,target);
vec_diff(temp,target,my.x); // Zielvector ermitteln
vec_to_angle(my.pan,temp); // Soldat zum Ziel drehen
my.tilt = 0;
if(vec_dist(my.x,my.pos_target) > 35)
}
wait(1);
}
{
force.x = 5; // Geschwindigkeit des Soldaten
vec_diff(temp,my.pos_target,my.x);
vec_to_angle(my.pan,temp); // Zur Zielposition drehen
my.tilt = 0;
gravity_entity(); // Gravitation
move_entity(); // Bewegen des Soldaten
Beginnen wir mit der ersten Zeile "while(player == null){wait(1);}", wir warten so lange bis der
Player erstellt ist, um eine "Empty Pointer" Fehlermeldung zu umgehen. In den nächsten vier
Zeilen werden die Parameter aus dem Array ausgelesen und in den Variablen "my.x_pos" und
"my.y_pos" gespeichert. Als nächstes erstellen wir die Hilfsentity an den vorher ausgelesenen
Positionen und weisen ihr den "you" Pointer zu. Das Ganze speichern wir mit Hilfe eines "handle" in
dem "skill.40" unseres Soldaten. Den "you" Pointer benötigen wir später noch, um immer zu
wissen welche Hilfsentity zu welchem Soldaten gehört. Nun befinden wir uns wieder in einer
Schleife, dort wird der "you" Pointer ausgelesen und mit seiner Hilfe ein "trace" vom Soldaten zur
Hilfsentity ausgeführt. Das Ziel wird im "target" Vektor gespeichert und anschließend der Soldat in
Richtung des Ziels gedreht. Nun springen wir wieder in eine "if" Anweisung, in der wird der
Abstand zu unseren Ziel berechnet. Ist die Entfernung größer als 35 Quants wird die
Geschwindigkeit des Soldaten auf "5" gesetzt, nochmals der Richtungsvektor berechnet und der
Soldat gedreht. Dann wird die Gravitation und die Bewegung des Soldaten aufgerufen.
Funktion "pos1_ent"
In dieser Funktion befinden sich alle Bewegungsbefehle der Hilfsentity.
function pos1_ent()
{
my.passable = on; // Mache mich passierbar
my.invisible = on; // Mache mich unsichtbar
vec_diff(temp,my.x,player.x); // Abstandsvektor zum Player
vec_set(my.x_pos,temp);
while(1)
{
vec_set(temp,my.x_pos);
vec_add(temp,player.x); // Abstandsvektor und Playervektor addieren
vec_set(my.x,temp); // Hilfsentity zum Player ausrichten
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │74

}
}
wait(1);
Als Erstes wird die Hilfsentity passierbar und unsichtbar geschalten, daß sie für den Soldaten kein
Hindernis darstellt. Danach wird der Abstandsvektor zum Player berechnet, daß die Entity immer in
der gleichen Entfernung zum Player steht. In der "while" Schleife wird stetig dieser Abstand zu den
Koordinaten des Players addiert und die Hilfsentity dementsprechend bewegt. Rufen Sie nun Ihr
Level auf und setzen Sie mehrere Entities in Ihr Level. Der Führungsentity weisen Sie die Aktion
"haupt_player" zu und den Entities die ihm folgen sollen die Aktion "entitys". Sollten Sie alles
richtig gemacht haben müßte es so aussehen wie auf diesem Screenshot. Die Soldaten laufen zum
Player und stellen sich in Keilformation hinter ihm auf.
So, wir sind nun am Ende des Tutorial angekommen. Ich hoffe es hat Ihnen etwas geholfen. Wenn
Sie jetzt sagen,"aber da fehlt ja noch Einiges.", dann haben Sie recht. In einem der nächsten
Tutorials werden wir die Kamera ausbauen. Sie wird zoom-, dreh- und schwenkbar werden,
desweiteren werden sich die Soldaten dann auch nach dem Pan-Winkel des Player bewegen und
nicht wie hier nur geradlinig. Wir werden auch versuchen mehrere Formationen anzulegen und
abzuspeichern und wieder aufzurufen. Auch die Animation und Kollisionsüberwachung fehlt noch,
genauso werden wir auch noch ein Sprite für die Zielpositionen einbinden. Aber wie schon gesagt
das wird noch in späteren Tutorials kommen.
Für Fragen oder Kommentare stehe ich gerne zur Verfügung.
Unter
aras_game@chefmail.de
können Sie alles in Bezug auf dieses Tutorial loswerden.
Dann bis zum nächsten Tutorial Ihr
Dieter "ARAS14" Meier
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │75

Interview... mit Sebastian Leopold (Xexes)
3DGS-Magazin:
Im Rahmen eines der Projekte, an denen Du beteiligt warst, hast Du einige Grafik-Funktionen
entwickelt. Was war der Hauptgrund für diese Arbeit? Was fehlte euch an A6?
Sebastian Leopold:
Durch die Einschränkung auf die Commercial Edition von A6 konnten wir Features wie „render-totexture“,
welches für unser Projekt unerlässlich war, nicht nutzen. Die Grafikfunktionen wurden
also aus der Not geboren. Als der Grundstein dafür dann einmal gelegt war, wollten wir auch noch
andere Features verwenden, die wir selbst einbauen mussten, da 3DGS keine Möglichkeiten dafür
bereitstellte.
Dazu zählen beispielsweise Spiegel und Post-Processing.
3DGS-Magazin:
Kannst Du uns eine kleine Übersicht von Funktionen geben, die Du in diesem Rahmen eingebaut
hast?
Sebastian Leopold:
Natürlich:
- Spiegel
- Wasser-Renderer
- Sky-Renderer
- A6 Mesh-Renderer
- Texturverwaltung mit HDR-Unterstützung
- PostProcessing Effekte
- Softshadows
3DGS-Magazin:
Das klingt sehr interessant. Kannst Du einige Worte zum Sky- und Mesh-Renderer schreiben?
Sebastian Leopold:
Der Sky-Renderer ist recht einfach aufgebaut. Es ist eigentlich nur eine Klasse für eine Skybox, die
sich in der Render-Liste befindet. Man braucht jedoch nicht für jeden Sky ein Modell und auch
keine unnötigen Definitionen eines Skies in C-Script. Es reicht aus, einfach eine Textur zu laden
und sie zuzuweisen. Das ganze geht in 6 Zeilen Code.
Der Mesh-Renderer verwendet das Sylex 3.0 Effektsystem und zeichnet 3DGS Modelle bzw.
Entities. Dadurch wird es möglich Render-Targets sehr schnell auf Modelle zu transferieren
3DGS-Magazin:
Du hast das Sylex 3.0 in der aktuellen Version mit Quellcode zur Verfügung gestellt und gut
dokumentiert. Die User waren sehr beeindruckt. Willst Du irgendwann an dem System weiter
arbeiten oder wirst Du nur hin und wieder mal schauen, was die Nutzer damit anstellen?
Sebastian Leopold:
Ich habe es mit Sourcecode veröffentlicht damit die User es selbst weiter entwickeln können. Ich
selbst werde nichts mehr daran machen.
3DGS-Magazin:
Gibt es schon weitere Pläne in Sachen Spiele-Entwicklung bei Dir?
Sebastian Leopold:
Naja - aufgeben werde ich nicht. Es gibt aber auch noch keine konkreten Pläne. Ich habe aber
mehrere Angebote von Entwicklerteams, dort als Programmierer zu arbeiten. Vielleicht entwickle
ich aber auch eine eigene 3D-Engine.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │76

3DGS-Magazin:
Du warst mit Sylex sehr erfolgreich. Warum setzt Du dort nicht an und erstellst ein kommerzielles
Plugin? Im Forum gab es einige Stimmen, die bereit wären, dafür zu zahlen.
Sebastian Leopold:
Ich möchte eigentlich nicht mehr mit A6 arbeiten, da mir die Engine zu viele Einschnitte macht.
Außerdem ist es einfacher, eine Engine von Grund auf zu entwickeln, als ein Plugin für eine bereits
Bestehende zu erstellen. Wenn ich eine neue Engine programmiere, soll sie auf RTS-Spiele
optimiert werden.
3DGS-Magazin:
Ja, das können sicher einige Leute verstehen. Dennoch wird die Community leider ein sehr
talentiertes Mitglied weniger haben.
Gibt es Tipps, die Du den Lesern geben kannst, bezüglich deren Projekte und Team-Management,
sodass sie aus euren Erfahrungen und Fehlern lernen können?
Sebastian Leopold:
Es sollte immer festgelegt sein, welches Aufgabengebiet welches Teammitglied hat. Des Weiteren
halte ich es für sehr sehr wichtig, sich zuerst eine funktionierende Testumgebung aufzubauen. In
meinen Projekten war ich meistens der einzige Programmierer. Oft kam es vor, dass Leveldesigner
versucht haben, die Skripte nach Ihren Wünschen selbst zu verändern. Das bringt aber nichts. Ein
zentrales Portal für alle Mitglieder, wie ein Forum, ist also Pflicht.
Davon abgesehen kann ich eigentlich nur raten, dass man ein Quellenverzeichnis führt, in welchem
man auflistet, wo man welche Textur her hat. Einheitliche Namensgebungen erleichtern die Arbeit
und zum Thema Team-Management wird noch etwas kommen, da dürft ihr euch mal überraschen
lassen.
3DGS-Magazin:
Wirst Du der Community noch eine Weile erhalten bleiben?
Sebastian Leopold:
Na sicher, Unkraut vergeht nicht!
3DGS-Magazin:
Vielen Dank für das Interview.
Sebastian Leopold:
Ich Danke !
Das Interview wurde von Frank Geppert im Auftrag des 3DGS-Magazins durchgeführt.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │77

Interview... Martin (SFMAT4) und Timo (TripleX)
3DGS-Magazin:
An welchen Projekten arbeitet Ihr zur Zeit?
zu ihren derzeitigen Projekten
Martin:
Defender Competition Demo Level und am Material Editor. Ich helfe Harry Potter noch bei seinem
Mittelalter-Projekt
Defender Competition wird ein Frist Person Ego Shooter ähnlich der UT-Serie. Mit dem Unterschied,
das hier nicht Mann gegen Mann antritt, sondern der Spieler ein Level gegen anströmende
Gegnerhorden verteidigen muss. Dabei kann er Geschütze aufstellen (und bedienen) oder Söldner
anheuern.
Der Material Editor (oder wahrscheinlich GameEdit) wird ein Tool mit dessen Hilfe der User in der
Engine weit reichende Änderungen vornehmen kann.
Bei beiden arbeite ich eng mit TripleX zusammen, wobei Trip fast alle Skript-technischen Aufgaben
übernimmt. Ich erstelle sämtliche Grafiken und Effekte.
3DGS-Magazin:
Wenn ich das richtig verstehe, dann ist doch der Material-Editor schon weit mehr als nur ein
Material-Editor. Wie weit wollt ihr mit dem Tool gehen?
Martin:
Ich denke wir werden ihn soweit ausbauen, wie es für interne Änderungen im Spiel sinnvoll ist,
und ergänzen das, was von den 3dgs Usern gewünscht wird.
Timo:
Da ich die letzten 2 Monate sehr intensiv am Map Material-Editor programmiert habe, ist nun
tatsächlich schon sehr viel mehr möglich, als ursprünglich geplant war. Allerdings müssen wir auch
Grenzen setzen, da man theoretisch fast unbegrenzt viele Features einbauen könnte.
Man wird z.B. Materialien, Actions und Positionen von Entities direkt im Spiel ändern können.
3DGS-Magazin:
Kehren wir wieder zu Eurem Spiel-Projekt zurück. Wie weit seid Ihr damit fortgeschritten?
Martin:
Das ist schwer zu sagen, weil mir immer wieder was neues einfällt. Ich denke, dass ich mit dem
Level und den Grafiken zu 90% fertig bin und skript-technisch hinkt Trip leider noch hinterher.
Daher würde ich das auf maximal 40% einstufen.
Timo:
Tatsächlich hinke ich skript-technisch noch etwas hinterher, was größtenteils daran liegt, dass ich
parallel am Material Editor arbeite, um Martin eine möglichst mächtiges Tool zum Map optimieren
geben zu können. Allerdings werde ich mich nun mehr auf das Spiel Konzentrieren.
3DGS-Magazin:
Habt Ihr schon Charakter-Modelle für die Spieler und Gegner?
Martin:
Nein, leider noch nicht.
3DGS-Magazin:
Was könnt Ihr aus Eurer Erfahrung zur A6-Engine sagen? Wie gut passt sie zu Eurem Projekt?
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │78

Martin:
Die A6 Engine ist ausreichend für das Projekt. Allerdings hatte ich vor einiger Zeit massive
Probleme, was die Lightmap-Grenze anbelangte. Leider ist die Shader-Unterstützung nicht so, wie
man es sich wünscht. Insgesamt gesehen bewege ich mich am Limit der Engine. Mit verschiedenen
Tricks lassen sich aber immer noch irgendwo einige FPS heraus kitzeln.
Timo:
Wie Martin schon gesagt hat, gehen wir mit unserem Projekt sehr an die Grenzen der A6-Engine.
Aber das ist ja auch unser Ziel: Ein 3D Gamestudio Projekt erschaffen, das das volle Potenzial der
Engine zeigt.
3DGS-Magazin:
Wie lange arbeitet Ihr schon an dem Projekt?
Martin:
Seit bestimmt 3 Jahren. Allerdings habe ich lange Pausen dazwischen eingelegt und schon fertige
Dinge durch neue bessere ersetzt.
3DGS-Magazin:
Woher bekommt Ihr Eure guten Texturen?
Martin:
Die erstelle ich alle selbst mit Photoshop und meiner Digicam.
Einige Grundstrukturen habe ich von Noctua-Graphics.
3DGS-Magazin:
Martin, Welche Software-Tools nutzt Du, welche Tipps kannst Du den Lesern geben?
Martin:
Ich benutze 3dsmax und Photoshop.
Bei 3dsmax hat es sich bewährt die dort erstellten Modelle über 3ds zu exportieren und im MED zu
importieren. Damit kann man sogar komplex texturierte Objekte verlustfrei in die A6 Engine
bekommen.
3DGS-Magazin:
Martin, ich habe gehört, Du arbeitest an einer für die Leser vielleicht sehr interessanten Webseite.
Kannst Du uns dazu einiges sagen?
Martin:
Ich versuche eine Shader-Bibliothek aufzubauen.
Möglichst viele A6 Shader sollen mit umfangreichen Erläuterungen und Beispielen dort verfügbar
sein.
3DGS-Magazin:
Vielen Dank für das nette Gespräch.
Das Interview wurde im Auftrag des 3DGS-Magazins von Frank Geppert durchgeführt.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │79

Game-Edit
Ein Preview des Map-Editors
Hallo,
Im folgendem werde Ich Ihnen, den sich im Moment in Entwicklung befindenden, Map-Editor
Game-Edit vorstellen.
Die Idee hinter Game-Edit
Die grundsätzliche Idee hinter dem Tool Game-Edit ist einfach: Der User implementiert das Tool
mit 2-3 simplen Befehle in sein Projekt und kann ab nun über einen einfachen Knopfdruck den
Map-Editor öffnen, in dem das Level und vorhandene Materials bearbeitet werden können. Die
Änderungen sind alle Ingame sichtbar (z.B. das verschieben eines Entities um eine bestimmte
Quantanzahl).
Das alleine wäre noch nicht sonderlich spannend wenn Game-Edit nicht alle veränderten Daten
direkt in der Map-/Wdl Datei speichern würde. Falls nötig wird sogar am Ende des Spiels gebuildet.
Auf Deutsch heißt das, dass alle Änderungen die Sie in Game-Edit vornehmen auch über einen
Neustart hinweg gespeichert bleiben.
Anwendungsbeispiele
„Das ist ja schön und gut nur wozu brauche ich das, ich habe doch WED“ werden Sie sich vielleicht
fragen. Daher werde ich Ihnen nun ein Anwendungsbeispiel zeigen.
Feature List
• Sie starten Ihr Projekt (im folgenden Beispiel einen Ego-Shooter) und spielen es ganz
normal. Beim kämpfen durch Ihr Level fällt Ihnen auf, dass der Spieler an einer bestimmten
Stelle dringend noch eine Waffe/Ammopack/Lebenspack bräuchte. Deshalb öffnen Sie
innerhalb des Spiels über einen Tastendruck den Map-Editor und platzieren ein neues
Ammopack (u.ä.) im Level. Nun verlassen Sie Game-Edit gleich wieder und können ganz
normal – mit dem neuen Ammopack weiterspielen. Dadurch ist es gut möglich, ein gutes
Fine-Balancing zu erschaffen.
• Grundsätzlich ähneln sich alle Anwendungsbeispiele sehr (bestimmte Einstellungen werden
eben verändert), daher werde ich hier auf weitere verzichten.
Schon eingebaut:
• Echtzeit-Bearbeiten der Einstellungen von Modellen / Sprites und Terrains
• Echtzeit-Bearbeiten der Einstellung von Materials. Unter anderem ist es auch möglich
Shader Code usw. zu bearbeiten.
• Ein automatischer Material Loader, der Ihren Code nach Material Definitionen durchsucht
und falls nötig überschreibt.
• Erschaffen, Entfernen und Morphen von Materials und Entities
• Verändern der Map-Properties (Nebel u. Ambientfarben, Clipping Einstellungen)
• Eine Objektliste, die alle Objekte die in der Map vorhanden sind anzeigt. Dadurch ist es
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │80

möglich mehrere Entities auf einmal zu verändern.
• Eine einfach gehaltenes GUI.
Geplant:
Screenshots
• Echtzeit-Deformierung von Terrains und Modellen
• Echtzeit-Zeichnen auf Skins von Modellen und Terrains.
• Ein umfangreiches Statistikfenster mit Graphen u.v.m.
• Mehrfach-Entitie Erschaffung, zum erstellen von mehreren Entities auf einmal (Wälder usw.)
In diesem Kapitel gibt es noch einige Screenshots des Editors. Zu beachten ist, dass dies alles work
in progress (wip) Features sind. D.h. das der Editor noch in einer frühen Phase der Entwicklung ist
und sich daher noch einiges ändern und vermutlich auch verbessern wird.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │81

3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │82

3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │83

Daten und Fakten
Programmierer: Timo Stark aka TripleX
2D Designer: Martin Teichmann aka SFMAT4
633 KB und 16422 Zeilen Code
2 Monate Entwicklungszeit
Geschätzt, weitere 2 Monate Entwicklungszeit nötig.
Einbindung in Ihr Projekt
Das einbinden von Game-Edit in Ihr entsprechendes Projekt wird sehr einfach vonstatten gehen. Es
ist auch für absolute Nicht-programmierer schaffbar.
Ein Beispiel der Einbindung:
material_init("Maps"); //Alle Map Daten liegen in dem Unterordner "Maps"
Material_Bind_WDL("Data\\Scripts\\materials.wdl"); //Teilt der Engine mit, dass in der
Materials.wdl Materialien liegen
Material_Bind_WDL("main_op.wdl"); //Teilt der Engine mit, dass in der Main_op.wdl Materialen
liegen
//bis zu 40 WDL Dateien sind so einbindbar!
Ich hoffe dass diese Preview Ihnen einen Einblick in Game-Edit gewährt hat.
3D GAMESTUDIO-Magazin ■ Ausgabe 01 | Oktober 2005 │84