parrotengine

ParrotEngine - Getting Started

Einrichten der Entwicklungsumgebung

Zuerst Eclipse downloaden von www.eclipse.org/downloads. Am einfachsten ist es, hier die "Eclipse IDE for Java Developer" zu nehmen. Die Parrot Engine stellt keine besonderen Anforderungen an die Eclipse-Variante, hauptsache die JDT (Java Development Tools) sind dabei. Das heruntergeladene Eclipse kann dann in einen beliebigen Ordner entpackt werden. Danach empfiehlt es sich auch das JDK6 von java.sun.com herunterzuladen und zu installieren - dadurch wird es möglich auch in Eclipse Ant-Skripte laufen zu lassen und Programme zu debuggen. Außerdem enthält das JDK eine Menge andere nützliche Tools für Entwickler.

Nach dem Start von Eclipse erscheint zunächst die Frage nach einem Workspace - hier kann ein beliebiger Ordner gewählt werden.

Ist Eclipse schließlich gestartet, sollte im Dialog unter "Windows / Preferences" auf der Seite "Java / Installed JREs" noch das soeben installierte JDK hinzugefügt und als Default ausgewählt werden indem der Haken vor dem JDK gesetzt wird.

Das Complete-Package der Parrot-Engine downloaden und an einem beliebigen Ort speichern.

Unter Eclipse im "Package Explorer" Fenster mit der rechten Maustaste "Import" und in dem sich öffnenden Dialog dann "General / Existing Projects from Workspace" auswählen. Dort dann das heruntergeladene Parrot-Engine Archiv angeben unter "select archive file". In der Liste der gefundenen Projekte dann die Parrot Engine auswählen und "Finish" klicken.

Die Engine ist nun als Projekt in Eclipse eingerichtet und kann gebaut werden:

Blendet mit "Window / Show View / Ant" die Ant-View ein und fügt dann in der neu erschienenen View mit dem Titel "Ant" mit dem Kontextmenü "Add Buildfiles" das build.xml aus dem ParrotEngine Projekt hinzu.

Klappt den Eintrag "TheParrotEngine" auf und doppelklickt dann auf "all". Der Build-Prozess startet nun und sollte ohne Fehler beenden.

Nun könnt ihr bereits die Beispiele starten indem ihr das Ziel "run-samples-browser" doppelt anklickt! Das Programm zum Aufrufen der Samples wird dann gestartet.

Eigene Programme mit der Engine schreiben

Erstellt ein neues Java-Projekt und ruft anschließend die Properties des Projekts auf und wechselt dort in das Pane "Java Build Path". Dort muss das ParrotEngine-Projekt hinzugefügt werden. Dies geschieht in dem Tab "Projects" mit dem Button "Add Jars". Wählt dann das "TheParrotEngine" Projekt aus. Durch diesen Eintrag bekommt das neue Projekt Zugriff auf die Klassen und Daten der Engine.

Erstellt nun eine neue Klasse "Test" die folgenden Code beinhaltet:

import de.gaffga.parrotengine.engine.Engine;
import de.gaffga.parrotengine.engine.EngineException;

public class Test {

    public static void main(String[] args) throws EngineException {
        Test test = new Test();
        test.start();
    }
   
    public void start() throws EngineException {
        Engine engine = new Engine();
       
        engine.start();
    }
}

Nun muss noch eine neue Run-Configuration für diese Klasse erstellt werden. Dies geht unter "Run / Run Configurations"; dort ist "Java Application" auszuwählen und dann mit dem Icon "New launch configuration" ein neuer Eintrag zu erstellen. ACHTUNG: Stellt unbedingt sicher, dass unter der Registerkarte "JRE" in der Run-Configuration das JDK 1.6 das ihr oben eingetragen habt eingestellt ist - sonst gibt es Probleme mit der Darstellung von Texturen.

Wenn ihr das Programm startet, erhaltet ihr kurz den Startbildschirm der Engine und anschließend einen schwarzen leeren Screen. Das Programm kann über das Schließen des Fensters oder über die Console mit "^" und anschließend "quit"+Enter beendet werden. Hier gibt es weitere Infos zu den Console-Kommandos.

Ihr habt nun das erste Programm mit der Engine erstellt. Jetzt können weitere Features integriert werden. Schaut euch dazu am besten mal die Beispiele an. Diese befinden sich unter dem Projekt "TheParrotEngine" im Ordner "src" im Paket "de.gaffga.parrotengine.samples".

Dokumentation der Console-Kommandos

Tastaturbelegung

Taste Funktion
^ Ein-/Ausblenden der Console.
Tab Ausführen der automatischen Vervollständigung. Falls der eingegebene Text eindeutig weiter ergänzt werden kann wird er das. Ist das nicht der Fall, werden alle bekannten Eingaben aufgelistet die mit der bereits getätigten Eingabe möglich sind. Das Drücken von Tab ohne etwas eingegenen zu haben listet somit alle vorhandenen Kommandos und Variablen auf.
Seite hoch / runter Anzeigen von älteren/neueren Ausgaben der Console. Mit diesen Tasten kann man sich Ausgaben die bereits oben über den Bildschirm hinausgelaufen sind wieder zurückholen.
Cursor hoch / runter Durchschalten durch die bereits eingegebenen Kommandozeilen. So kann man sich eine bereits eingegebene Zeile wiederholen und zum Beispiel dann einfach nur den mitgegebenen Parameter verändern und erneut ausführen lassen.
Cursor links / rechts / Pos1 / Ende / Entf / Backspace Dies ist die übliche Navigation und Bearbeitung einer Zeile mit dem Cursor.

Kommandos

quit

Beendet die Anwendung und die Engine sofort.

dump_timer

Gibt eine Liste aller registrierten Timer mit deren aktuellem Wert in ms aus.

d_add_graph "TIMER_NAME"

Fügt einen neuen Performance-Graphen hinzu der die Werte des angegebenen Timers anzeigt. Der Name ist aus der dump_timer Liste zu entnehmen und muss als String in Anführungszeichen angegeben werden.

d_remove_graph "TIMER_NAME"

Entfernt den angegebenen Timer aus dem Performance-Graphen wieder.

Variablen

d_draw_boundingspheres BOOL

Falls BOOL 1 ist, werden für alle Objekte die zugeordneten Bounding Spheres gezeichnet.

d_draw_names BOOL

FallsBOOL 1 ist, werden die Namen aller Objekte angezeigt.

d_draw_names_size BOOL

Stellt die Größe ein in der die Namen der Objekte gezeichnet werden.

d_draw_perf_infos BOOL

Falls BOOL 1 ist, werden die Performance Graphen angezeigt.

d_draw_statistics  BOOL

Falls BOOL 1 ist, wird ein Fenster mit wichtigen Kennzahlen eingeblendet.

d_skybox_visibleBOOL

Falls BOOL 0 ist, wird die Skybox abgeschaltet, 1 schaltet sie wieder ein.

d_draw_particle_systems BOOL

Falls BOOL 1 ist, werden Partikelsysteme gezeichnet, bei 0 nicht.

d_terrain_lod_factor FACTOR

FACTOR ist ein Wert der die Geschwindigkeit bestimmt wie schnell das Terrain vom feinsten LOD zum gröbsten LOD übergeht. Werte <1 können zu Darstellungsfehlern führen, Werte >1 führen zu sehr langsam abnehmenden LOD.

d_terrain_lod_near DISTANCE

Gibt an bei welcher Distanz gerade noch der feinste LOD verwendet werden soll. Terrainblöcke die weiter entfernt werden bekommen abnehmende LOD Levels zugeteilt.

d_terrain_frustum_culling BOOL

Falls BOOL 1 ist, wird für die TerrainBlöcke Frustum Culling durchgeführt, bei 0 nicht.

Skinning Teil 1

Ein Beispiel-SkelettEin Beispiel-Skelett

Mittels Skinning ist es möglich 3D-Figuren zu animieren. Das Prinzip ist ähnlich wie in der Natur: Haut ("Skin") und Fleisch befinden sich auf einem Knochenskelett. Muskeln greifen an den Knochen an um mit ihnen die Haut zu bewegen. Sie bewegt sich mit, da sie fest mit dem Rest des Körpers verbunden ist. Das Skinning zur Animation von virtuellen Figuren funktioniert ähnlich: Indem Knochen direkt durch Transformationen bewegt werden. Das Mesh selbst stellt das Skin dar. Jedem Knochen ("Bone") des Skeletts werden nun Teile des Skins zugeordnet die sich mit der Bone bewegen sollen. Da es auch möglich ist, dass ein Bereich durch mehrere Bones beeinflusst wird, wird den Zuweisungen noch eine Gewichtung hinzugefügt - dadurch kann festgelegt werden wie stark eine Bone die Position eines Punkts ändert.

GPU-basiertes Zeichnen von 3D-Terrains

Stitching eines groben an einen feinen LODStitching eines groben an einen feinen LOD

In diesem Artikel möchte ich beschreiben wie die derzeitige Implementierung des Terrain-Moduls in der Parrot-Engine funktioniert. Meine alte Terrain-Implementierung war mir einfach viel zu langsam. Dieses neue Verfahren unterteilt das Terrain in Blöcke die nahtlos aneinandergefügt werden. Da dieses Verfahren deutlich weniger Geometrie prüfen und berücksichtigen muss, ist es deutlich schneller.

CPU-basierte Terrain Render Optimierung

Die Anbindung von unterschiedlichen DetailstufenDie Anbindung von unterschiedlichen DetailstufenTerrains werden benutzt um größere Gelände abzubilden. Vor allem in Spielen nehmen die Terrains einen immer größer werdenden Stellenwert ein, denn sie ermöglichen es mit überschaubarem Aufwand große Spielwelten zu erzeugen die zudem sehr realistisch wirken. Dekorative Elemente wie Bäume, Häuser und Felsen werden auf dieser Landschaft platziert so dass eine dicht bestückte Welt entsteht in der der Spieler sich dann frei bewegen kann.

Roadmap

Liste der kommenden Versionen und geplanten Features:

Release Geplante Features
0.2
(2. oder 3. Quartal 2009)
  • Einlesen von statischen Mesh-Objekten aus XML-Dateien. Die XML-Dateien können per Python-Export Skript aus Blender heraus exportiert werden.
  • Einführung eines erweiterbaren Material-Systems. Es soll über ein Tool möglich sein die Materialeigenschaften von Objekten nachzubearbeiten. Offen: Wie werden die Flächen mit verschiedenen Materialen in Blender "markiert"? (Idee: Material-Datenbank als Menge von XML-Material-Definitionen in einem Verzeichnis ablegen und pro Objekt nur noch ein Mapping vornehmen?)
  • Darstellen der statischen Objekte in der Map; unterstützen von Objektreferenzen und -gruppen in der Map-XML.
  • LOD für Meshobjekte realisieren (ob die LODs automatisch errechnet oder mitgegeben werden kann im Mesh-XML festgelegt werden)
  • Kollisionssystem für Terrain und statische Mesh-Objekte implementieren. Jedes Mesh hat ein "Kollisionsmesh" über das ein BSP-Tree oder Octree gelegt wird. Das Kollisionsmesh ist eines der LODs - welches ist offen/spezifizierbar.

Parrot Engine Featureliste

Stand: Release 0.2

Dies ist die Liste der Features die die Parrot Engine in ihrer aktuellen Version unterstützt. Diese Liste wird aktualisiert sobald eine neue Version der Engine veröffentlich wird.

Terrain Rendering

  • Erstellen des Terrains aus einer Heightmap heraus mit bis zu 16bit Auflösung der Höhendaten
  • Terraindetails werden konfigurierbar mit der Entfernung geringer (LOD)
  • Das Terrain wird in Blöcke unterteilt die jeweils direkt mit der Hardware gerendert werden

Szene-Baum

  • Eine Szene besteht aus einer Baumstruktur.
  • Jeder Knotenpunkt des Baums hat eine BoundingSphere die alle Objekt unter ihm beinhaltet.
  • Die BoundingSpheres werden beim Zeichnen für das Frustum Culling verwendet.
  • Sowohl Terrains, als auch Partikelsysteme sind Objekte die sich in den Szene-Baum einfügen lassen.

Skybox

  • Eine Skybox kann als Hintergrund verwendet werden um den Eindruck von weit entfernten Umgebungen zu bieten.

Mesh-Objekte

  • Mesh Objekte können aus Blender heraus exportiert werden - dabei werden Vertex Colors und/oder Texturen und u/v Koordinaten entsprechend berücksichtigt.
  • Vorderfinierte Objekte sind vorhanden und können als Dummies/Platzhalter/Markierungen eingefügt werden: Sphere, Box und Disc
  • Mesh-Objekte können instanziert werden und teilen sich die VertexBufferObjects um Speicher zu sparen

Partikelsysteme

  • Partikelsysteme können einfach mit dem Partikel-Editor erstellt und später in eigenen Programme verwendet werden.
  • Die Partikel können in Bezug auf Schwerkraft, Beschleunigung, Rotation, Farbverlauf, Textur und Zufallsbereiche konfiguriert werden
  • Partikelsysteme können unterschiedliche Emitter haben - z.B. auch ein beliebiges Mesh-Objekt das dann Partikel von dessen Flächen aus emittiert - so kann z.B. ein Objekt als brennend dargestellt werden.

Resource-Verwaltung

  • Resourcen werden alle über eine "AbstractInputStreamSource" Klasse geladen. Diese Klasse liefert zu einem Pfadnamen einen InputStream. Dadurch können beliebige Quellen für Resourcen verwendet werden (ZIP Files, Netzwerk, lokale Dateien).
  • Über eine Zwischenschicht wird ein Fallback-Szenario für Resourcen geschaffen: Resourcen können dadurch von Applikationen die Defaults überladen.

Konsole

  • Über ein Konsole-Interface können wichtige Variablen zur Laufzeit verändert werden
  • Variablen die in die Konsole eingebunden sind verlangsamen den Programmablauf nicht
  • Beliebige Kommandos können nachträglich und zur Laufzeit hinzugefügt werden
  • Die Eingabevervollständigung unterstützt bei der Eingabe der Variablen und Kommandos

Textausgabe

  • 3D-Text kann aus normalen TTF-Fonts erstellt und als Objekt in einer Szene verwendet werden. Die so erstellen Objekte sind bereits mit u/v Koordinaten versehen. Der Detailgrad der Zeichen kann über eine Qualitätsstufe beeinflusst werden.
  • Schneller Text kann mittels Bitmap Fonts ausgegeben werden - und dies sowohl in 2D als auch in 3D hinein projiziert.
  • Zur Erstellung der Bitmap Fonts wird das Tool "FontCreator" mitgeliefert.

Timer

  • Über ein Timer-System können Zeitmessungen vorgenommen werden
  • Timer-Werte können mittels Performance-Graphen grafisch über den Zeitverlauf hinweg angezeigt werden.

Endlicher Automat

  • Ein endlicher Automat ermöglicht die Unterteilung einer Anwendung in klar abgegrenzte Zustände
  • Die Übergänge der Zustände untereinander, sowie die Definiton der Events erfolgt über eine XML Konfiguration

Audio-System

  • Das enthaltenene Audio-System spielt WAV und OGG Dateien ab und kann diese mit beliebigen Lautstärken mischen.

RenderStates

  • Über den bekannten aktuellen Renderzustand werden die nötigen Aufrufe von OpenGL-Kommandos verringert
  • RenderStates werden je nach Notwendigkeit entsprechend sortiert - z.B. Blended states von hinten nach vorn gezeichnet

Parrot Engine Releasehistorie

Release Released am Beschreibung
0.1 03.01.2009 Erstes öffentliches Release der Engine.

  • OpenGL Abstraktionsschicht
  • Konsole Interface
  • Terrain Renderer:
    • LOD von Terrainblöcken

    • Detailtexturen die in der Entfernung verblassen
  • Skybox
  • Ressourcen allgemeingültig über InputStreams laden
  • Mapdefinition aus XML Dateien lesen
  • Scenegraph mit Frustum Culling
  • Freie Kameraposition (Frustum)
  • Textrenderer
  • Vorbereitungen für Mesh Rendering
  • Vorbereitungen für Skeleton Animation von Meshes
  • Vorbereitungen für Kollisionserkennung

Parrot Engine

Dies ist die Hauptprojektseite meines Projekts der "Parrot Engine". Das Projekt zielt daraufhin eine frei verfügbare, performante und flexible 3D-Engine für Java Applikationen bereitzustellen. Der primäre Fokus liegt eindeutig auf die Entwicklung von Spielen, die tatsächliche Nutzbarkeit der Engine ist aber natürlich nicht nur darauf beschränkt. Von dieser Seite aus sind alle wichtigen Bereiche des Projekts verlinkt - es genügt also allein diese Seite als Bookmark zu haben.

Status

Die Engine ist derzeit noch nicht für den "Echteinsatz" nutzbar, da eine essentielle Funktionalität noch fehlt: Die Kollisionserkennung! Diese wird aber im nächsten Release enthalten sein so dass ich dann auch die ersten kleinen spielbaren Demos werde zeigen können.

Überblick

Dokumentation

Downloads

Hier könnt ihr die Releases der Engine als Source herunterladen. Falls verfügbar gibt es auch zu der Version passende Pakete mit Demos.

Release Datum Beschreibung
0.2 30.03.2010 parrotengine-0.2-complete.zip (27MB)
Das komplette Paket inklusive aller Quelltexte, Libs, Dokumentationen, Demos und Daten

parrotengine-0.2-doc.zip (1,2MB)
Die JavaDoc API Referenzdokumentation

parrotengine-0.2-3rdpartylibs.zip (1,7MB)
Die 3rd Party Libraries die die Engine benötigt

parrotengine-0.2-engine-data.zip (15MB)
Das Default-Datenset der Engine

parrotengine-0.2-samples-data.zip (8MB)
Die Daten für die Beispielprogramme

parrotengine-0.2-samples-src.zip (29kB)
Die Quelltexte nur der Beispielprogramme

parrotengine-0.2-src.zip (380kB)
Der Quelltext der Engine selbst.
0.1 03.01.2009 parrotengine_src_0.1.zip
Source Code Paket

parrotenginedemos_src_0.1.zip
Source der Demos

parrotengine_doc_0.1.zip
Java API Documentation

Lizenz

Das Projekt und die damit verbundenen Quelltexte und Datendateien der Parrot Engine unterliegen sämltlich der GNU Lesser General Public License (LGPL). Die Quelltexte und Daten der Demoprogramme unterliegen jedoch der GNU General Public License (GPL).

Syndicate content
OpenGLBlenderDrupal poweredSpieleentwicklertreff NRW