Hallo zum dritten Teil der Serie. In diesem Teil soll es darum gehen einen Partikeleditor zu entwickeln. Warum gerade einen Editor und warum Partikel?? Zum einen will ich zeigen, wie einfach es ist, am Mac Editoren mit OpenGL zu entwickeln und zum anderen brauchen wir für unser zweites Spiel Partikel-Effekte.

Zuerst muss vielleicht die Frage geklärt werden was Partikel überhaupt sind und für was man sie in Spielen gebrauchen kann. Nun mit einem Partikel-System lassen sich z.B. Regen, Explosionen, Feuer, Rauchen usw… auf relativ einfache Weise darstellen. Hier mal ein Beispiel dafür, wie ein meiner Meinung nach guter Partikel-Editor aussehen kann:

http://www.wondertouch.com/

Die Anforderungen an ein Partikelsystem sind zum Teil sehr unterschiedlich, wenn wir z.B. Regen darstellen möchten braucht das System mitunter ganz andere Attribute als wenn wir z.B. Rauch darstellen wollen.

Hier stellt sich dann die Frage wie wir ein solches System implementieren.

„Bruteforce“ Man könnte ein System entwickeln, das so viele Partikeleffekte wie möglich darstellen kann. Man würde aber ganz schnell feststellen, das diese Methode schnell an seine Grenzen stößt, da wie gesagt die einzelnen Effekte unterschiedliche Attribute benötigen.

„Vererbbares System“ Hier würde man ein Basis-System erstellen das nur die nötigsten Attribute besitzt und vom diesen dann ableiten. Auf diese Weise wäre man schon relativ flexibel, was aber auch einen gewissen Overhead mit sich bringen würde.

„Skript-System“ Bietet am meisten flexibilität, leider aber auch am meisten Arbeit. Zu dem eigentlichen Partikel-System müßte man sich einen Parser bauen, der die Skripte verarbeiten kann, zudem muss das System schnell genug sein, damit es wärend des parsens nicht zu merklichen Verzögerungen kommt.

Ich habe mich um es einfach zu halten, für die erste Methode entschieden.

Ein Partikelsystem besteht aus

1. einem Emitter, dieser stellt sozusagen die Quelle dar, von der aus die einzelnen Partikel erzeugt werden
2. mindestens einem Partikel, das ist eben der Teil des System der auf dem Bildschirm gerendert wird

Attribute des Emitters (auszugsweise je nach System)

• Position (Vektor)
• Bewegung (Vektor)
• Gravitation (Vektor)
• Emissionsrate (erzeugte Partikel pro Sekunde)

Attribute der einzelnen Partikel (auch wieder auszugsweise)

• Position
• Bewegung
• Gravitation
• Grösse
• Farbe
• Texture

Nachdem wir nun wissen, aus was ein PartikelSystem grundsätzlich besteht, will ich mal ein bischen näher auf unser System eingehen

Der Editor besteht aus 2 Teilen. Zum einen die Toolbox in der die Eigenschaften für den Emitter und die Partikel eingestellt werden können und aus der Vorschau.

Beim Start des Programms lädt man zuerst ein passende Texture (ich hab mal einige mit dazugelegt) und klickt dann auf „init System“.

Danach kann man mit den verschiedenen Attributen experementieren, solange bis man den gewünschten Effekt hat. Schnell wird klar das man mit dem Editor z.B. kein Regen darstellen kann (dafür ist er nicht flexibel genug), darum soll es aber gar nicht gehen, sondern darum wie man ein Partikel-System machen kann. Was auf jeden Fall fehlt, ist ein Funktion zum laden und speichern.

Zuerst mal die 3 wichtigsten Methoden die jedes PartikelSystem und somit auch unseres hat:

1. init

wie der Name schon sagt wird hier das System initialisiert, also alle Attribute auf ihre Anfangswerte gesetzt.

1. update

Hier werden die Partikel bewegt, „Lebenszeit“ aktualisiert, wichtig ist hier das man die verstrichene Zeit (timeDelta) in die Berechnungen mit einbezieht. Da das System ja auf allen Rechnern gleich schnell ablaufen soll.

1. rendern

wie der Name schon sagt werden hier die Partikel auf den Schirm gebracht.

Ich will über den Punkt Draw-Mode im Editor noch kurz was erklären, bzw. wie ein Partikel grundsätzlich gerendert wird. Üblicherweise wird ein Partikel als „Billboard-Quad“ dargestellt.

Unter Billboarding versteht man, das die Geometrie (in unserem Fall ein Quadrat mit Texture) immer in Richtung der Kamera ausgerichtet ist. Das heisst egal von welcher Seite wir auf das Quadrat schauen, wir werden es immer von vorne betrachten. Hier nochmal ein ausführlicher Erklärung dazu: http://de.wikipedia.org/wiki/Billboard_(3D-Grafik) In unserem Editor haben wir die Möglichkeit als „Billboard“ oder als „Pointsprite“ zu rendern.

Ein Pointsprite ist nichts anderes als ein Hardwarebeschleunigtes Billboard, die Handhabung von Pointsprites ist im Gegensatz zu „handgemachten Billboards“ einfacher, da man sich um die Texturekoordinaten, bzw. die Ausrichtung der Vertexkoordinaten nicht selbst kümmern muss. Allerdings haben Pointsprites einige Nachteile die ich kurz erklären will:

• PointSprites gehören seit OpenGL 2.0 zu den Core-Features von OpenGL, das heisst Grafikkarten die OpenGL 2.0 nicht unterstützen

können unter Umständen keine PointSprites darstellen (in älteren OpenGL Versionen kann man mittels Extensions PointSprites darstellen).

• PointSprites sind Point's (GL_POINTS) im Sinne von OpenGL, das heisst man kann einen Punkt nicht rotieren (man kann aber im Fragment-Shader die Texturekoordinaten rotieren)

• Die maximale Größe der PointSprites ist abhängig von der Grösse eines Points (im Sinne von OpenGL, GL_POINTS)

• Man kann die Größe eines PointSprites nicht innerhalb von glBegin()/glEnd() verändern (man müßte das über ein Vertex-Attrribute in einem Vertex Shader tun)

Hier einige Punkte die beim Rendern von Partikeln wichtig sind

1. Da wir ja transparente Bereiche in unserer Texture haben, werden Partikeleffekte immer mit eingeschaltetem Blending gerendert.
2. DepthTesting ist immer ausgeschaltet
3. Die Beleuchtung ist immer ausgeschaltet
4. Ein PartikelSystem wird in der Regel immer NACH allem anderen gerendert (siehe Punkt 2)

Ich will hier auf einige Punkte im Code eingehen.

Hier wird das Partikelsystem erstellt eine Kamera installiert die Mosue-Events abgefangen (zum zoomen und rotieren) und die Szene gerendert (ich habe als Orientierungshilfe einen Boden und die 3 Richtungspfeile eingebaut).

ist wie der Name schon sagt unser System. Diese Klasse beinhaltet noch eine struct die einen einzelnen Partikel beschreibt. Die wichtigsten Methoden sind wie schon oben erwähnt

-(void)initSystem;
-(void)update:(float)timeDelta;
-(void)render;

#define NUMPARTICLES 200

Die Klasse die die Eingaben unserer Toolbox verarbeitet und an das Partikelsystem weitergibt. Die Klassen im Ordner GameStuff sollten aus den vorhergehenden Wikis schon bekannt sein.

http://en.wikipedia.org/wiki/Particle_system

http://www.gamedev.net/reference/articles/article1042.asp

http://www.particlesystems.org/

http://www.gamasutra.com/features/20000623/vanderburg_01.htm

So, das wars auch schon wieder für diesen Teil, ich hoffe es hat Euch ein wenig Spaß gemacht. Im nächsten Teil des Wikis möchte ich ein zweites Spiel machen, diesmal richtiges 3D . Wer Lust hat mitzumachen, soll sich bitte bei mir melden. In diesem Sinne, take care

wolf_10de

partikeleditor.zip