Graphisch-Interaktive Systeme

Transkript

1 Eine von Daniel Türpitz im Rahmen der Lehrveranstaltung

2 INHALTSVERZEICHNIS 1. Einleitung Was ist die Lightweight Java Game Library? Eigenschaften und Ziele von LWJGL Geschwindigkeit Portabilität Einfachheit Minimalismus Sicherheit Robustheit Aufbau und Komponenten von LWJGL OpenGL OpenAL Java Input API (JInput) FMOD DevIL Fazit Ausschnitt aus der Klassenhierarchie Installation von LWJGL Windows Linux/Unix MacOS Einrichten der Entwicklungsumgebung für LWJGL Eclipse Netbeans Praktischer Teil/Tutorial Das Grundgerüst einer LWJGL-Klasse Das Spiel Ping Pong Initialisierung Steuerung Objekte Bewegung des Balls Rendering Main-Loop Spielende Schlusswort Anhang Quellenangaben Einrichten der Entwicklungsumgebung Netbeans

3 1. Einleitung In der Computerwelt spielt Graphik eine immer größer werdende Rolle. Egal ob bei der Entwicklung von Benutzeroberflächen, bei der Animation von verschiedenen Lebewesen und Gegenständen oder bei Embedded Systems. Mittlerweile ist die Entwicklung so weit, dass es eine Vielzahl von Graphik- Bibliotheken und Graphik-APIs auf dem Markt gibt. Die Wichtigsten sind meiner Meinung nach DirectX und OpenGL. Beide werden in der Programmiersprache C implementiert und eignen sich zur Darstellung von Graphik ausgezeichnet. Insbesondere OpenGL gewinnt immer mehr an Bedeutung, da es sich um eine freie, plattformunabhängige Graphik-Bibliothek handelt, die auch von vielen Graphikkartenherstellern unterstützt wird. Genau dies ist der Vorteil von OpenGL im Gegensatz zu DirectX. Durch seine Plattformunabhängigkeit kann es auf vielen verschiedenen edenen Systemen genutzt und implementiert werden. Egal ob UNIX, Windows oder Embedded Systems (OpenGL ES), es bietet für jede dieser Umgebungen die richtige Lösung. Leider muss man sagen, dass sich OpenGL in der Spiele-Industrie nur langsam gegenüber DirectX durchsetzt. Auch weil DirectX die Möglichkeit bietet verschiedene Audio-Effekte zu realisieren. Da heutzutage objektorientierte Programmiersprachen wie Java und Co. immer wichtiger und einflussreicher werden, gibt es viele Bindings für OpenGL. Hierbei ist JOGL eines der Wichtigsten. Was ist aber mit den angesprochenen Möglichkeiten für Audio und Sound, vor allem 3D-Sound? Auch hierfür gibt es eine Lösung: LWJGL. Dieses Binding unterstützt OpenGL und OpenAL sowie eine Vielzahl anderer Bibliotheken. Deshalb kann LWJGL meiner Meinung nach als einzig wahrer Konkurrent zu DirectX gesehen werden und durch seine Plattformunabhängigkeit enorm Punkte sammeln. Ich möchte in dieser erläutern was LWJGL ist, welche Ziele die Entwickler damit verfolgen und d den Aufbau sowie die Erweiterungen kurz erläutern. Ziel soll es sein, die LWJGL auf den verschiedenen Plattformen installieren zu können und dementsprechend entsprechend die Entwicklungsumgebung einzurichten. Am Ende der soll an einem Beispiel gezeigt werden, wie man ein kleines Spiel mit der LWJGL in Java programmiert. 2. Was ist die Lightweight Java Games Library (kurz: LWJGL)? Bei der LWJGL handelt es sich um eine effiziente (deshalb lightweight) Programmbibliothek für die Programmiersprache Java mit dem m Fokus auf 3D- Spieleentwicklung. Mit der Hilfe von LWJGL kann ein Java-Programmierer auf OpenGL- und OpenAL- Funktionen zugreifen n (Binding). Hierbei wird OpenGL bis zur Version 2.1 mit den wichtigsten Extensions unterstützt. OpenAL ist bis zur Version 1.0 implementiert. Leider macht die LWJGL das Programmieren von 3D-Anwendungen nicht gerade leichter, vielmehr stellt sie Bibliotheken und Funktionen zur Verfügung die es so in der Java-Plattform noch nicht gibt. LWJGL unterstützt, außer der 3D-Grafik (OpenGL) und dem Sound (OpenAL), die Behandlung von Maus-, Tastatur- und Controllereingaben wie zum Beispiel Joystick oder Gamepad.. Damit stellt LWJGL eine plattformunabhängige Alternative (es existieren entsprechende 3

4 Implementierungen für Windows, UNIX und MacOS) ) zu Microsoft DirectX dar. Da DirectX aber nur unter Windows unterstützt wird, ist LWJGL hier klar im Vorteil. LWJGL basiert auf einer eigenen Fenster-Klasse, d.h. es ist unabhängig von AWT oder Swing. Das Fenster ist hauptsächlich für den Einsatz im Vollbild-Modus vorgesehen, kann jedoch mit einigen Einschränkungen auch im Fenster-Modus genutzt oder sogar in SWT-Umgebungen eingebunden werden. Desweiteren gibt es die Möglichkeit zur Verwendung von DevIL zum Laden und Bearbeiten von Bildern und FMOD zum Laden und Abspielen von Musikdateien. Bis zur Version 1.0 waren DevIL- und FMOD-Unterstützungen standardmäßig enthalten, wurden mit LWJGL 1.0 wieder entfernt und können nun bei Bedarf extra eingebunden werden. Die Bibliothek steht unter einer BSD-Lizenz (Open n Source) und wurde von Caspian Rychlik-Prince, einem Mitglied von PuppyGames, initiiert. Aktuell liegt die LWJGL in der Version vom 30.Oktober 2007 vor. Da ich mit den Vorbereitungen für diese jedoch schon vorher begonnen hatte, verwende ich in meinen Beispielen die Version vom 17. August Eigenschaften und Ziele von LWJGL (aus Die Entwickler der LWJGL hatten sich bestimmte Ziele gesetzt, die sie mit der LWJGL erreichen wollen. Durch einige dieser Ziele grenzt sich die Bibliothek auch klar von anderen APIs wie z. B. JOGL ab. Im folgenden Werte ich die Ziele kurz auflisten und etwas erklären. 3.1 Geschwindigkeit - Da die LWJGL auf Java beruht wurden einige Methoden von OpenGL, die in der Programmiersprache C effizient sind, in Java aber nicht, entfernt. So wurde z. B. die Methode glcolor3fv weggelassen. - Beim Start eines Programms wird immer überprüft, ob Hardware- Beschleunigung verfügbar ist. 3.2 Portabilität Die Bibliothek wurde so entworfen, dass sie sowohl auf kleinen Geräten wie Handys oder PDAs als auch auf Multiprozessor-Rendering-Servern läuft. Leider gibt es derzeit noch keine Handys, die so schnell sind 3D-Spiele mittels LWJGL richtig darzustellen. Trotzdem hat man die Bibliothek so gestaltet, dass man für die Zukunft (neue Handys) gerüstet ist und die Unterstützung von OpenGL ES gewährleisten kann: - Um sicher zu stellen dass der Speicher von J2ME ausreicht, wurde die Basis von LWJGL klein gehalten. Deshalb sind die Binärdateien nicht größer als ein halbes Megabyte, ermöglichen aber trotzdem 3D-Sound, Graphik und Einbzw. Ausgaben. - Auch für Desktop-Anwendungen wäre es Verschwendung mehr als 1-2 MB für ein paar einfache 3D-Funktionen zu benutzen. - Die Entwickler haben versucht auf den kleinsten gemeinsamen Nenner zu kommen,, der eine solche Funktionalität anbietet, und nicht für alle Eventualitäten gerüstet zu sein. Dennoch wird sicher gestellt das 99%, der für Spiele-Entwicklung nötigen Features, vorhanden sind. 4

5 3.3 Einfachheit Die Bibliothek wurde so entwickelt, dass sie sowohl für Anfänger leicht zu benutzen ist, als auch für Profis, die damit professionelle Anwendungen entwickeln möchten. Desweiteren wurde ein Modell entwickelt, dass sowohl zu OpenGL als auch zu den Geräten, vom PDA bis zum Desktop-PC passte: - Single-Buffered Modus wird nicht unterstützt - Dinge die man zum Spiele entwickeln nicht benötigt, wurden weg gelassen - Konsistenz geht vor Komplexität, deshalb werden keine Arrays sondern nur Buffer unterstützt,, da dies der schnellste Weg ist, Daten auf OpenGL-Ebene zu übertragen. 3.4 Minimalismus Damit bei der LWJGL die Portabilität bestehen bleibt, ist es hilfreich wenn das API klein ist. Ein minimaler Umfang an Funktionen ermöglicht eine bessere Übersicht über die Möglichkeiten und führt zu weniger Fehlern im Code. Daher wurden nur Methoden in die Library aufgenommen, die nicht direkt mit Java ausgeführt werden können. Deshalb wurde auch die GLU bis auf einige wichtige Methoden entfernt. 3.5 Sicherheit - Es werden keine Pointer sondern nur Buffer verwendet. - Die Buffer-Positionen und Limits werden überprüft um sicherzustellen, dass die Werte innerhalb des erlaubten Bereichs sind. 3.6 Robustheit - Die OpenGL-Fehlerüberprüfung findet im Java-Code statt, anstatt in einer separaten DLL. - Es werden Runtime-Exceptions statt Checked-Exceptions verwendet. Dadurch benötigt man weniger Try-Catch-Anweisungen. 4. Aufbau und Komponenten von LWJGL LWJGL setzt aus zwei OpenSource-Bibliotheken zusammen, die auf der Programmiersprache C beruhen und mit LWJGL in Java eingebunden werden. Einmal die Bibliothek OpenGL und zweitens die Bibliothek OpenAL. Des Weiteren können nützlich andere Bibliotheken wie das Java Input Output API, DevIL und FMOD als Erweiterungen verwendet werden. 5

6 Die folgende Darstellung soll den Aufbau beschreiben: Java-Plattform LWJGL (Binding/Wrapper) Als Zusatz DevIL (4.5) FMOD (4.4) OpenGL (4.1) OpenAL (4.2) JInput (4.3) Abb. 1: Aufbau der LWJGL (in Anlehnung an /M3G/) Die oben genannten Bestandteile befinden sich in den folgenden Packages der LWJGL: org.lwjgl org.lwjgl.devil org.lwjgl.fmod3 org.lwjgl.openal org.lwjgl.opengl org.lwjgl.opengl.glu org.lwjgl.util org.lwjgl.util.jinput (enthält die Klassen für DevIL) (enthält die Klassen für FMOD) (enthält die Klassen für OpenAL) (enthält die Klassen für OpenGL) (enthält die wichtigsten Klassen der GLU) (enthält JInput und erweitert org.lwjgl.input) 4.1 OpenGL (Open Graphics Library, 1992 bei Silicon Graphics entwickelt) Bei dieser Bibliothek handelt es sich um eine Spezifikation für ein plattform- und programmiersprachenunabhängiges API zur Entwicklung von 3D-Computergrafik. Der Standard beschreibt etwa 250 Befehle, die die Darstellung von 3D-Szenen in Echtzeit erlauben. Zudem können andere Organisationen, meist Graphikkartenhersteller, Erweiterungen definieren. Die Implementierung von OpenGL führt entsprechende Befehle auf der Grafikkarte aus. Die Funktionen die nicht auf der Grafikkarte vorhanden sind, werden durch die CPU emuliert. OpenGL ist der Hauptbestandteil von LWJGL und wird durch ein Binding in Java zur Verfügung gestellt. Meine soll ich im Wesentlichen um Grafik drehen, deshalb liegt der Schwerpunkt auf den Funktionen von OpenGL in der LWJGL. Grundkenntnisse von OpenGL setze ich voraus. 4.2 OpenAL (Open Audio Library, 1998 bei Loki Software entwickelt und seid 1999 zusammen mit Creative Labs) Bei OpenAL handelt es sich ebenfalls um eine plattformunabhängige API zur Entwicklung von 3D-Audio in der Spielebranche. Aber auch in anderen Audioanwendungen findet OpenAL ihre Verwendung. Es lassen sich Soundeffekte wie Raumklang (3D-Sound) und Dopplereffekt (z. B. Effekt beim Martinshorn) erstellen und einbinden. OpenAL unterliegt in weiten Teilen der 6

7 GNU (General Public License) und ist damit Freeware. Für die Xbox und Xbox360 0 liegt die Lizenz jedoch bei Creative Labs. OpenAL ist als direkte Ergänzung zu OpenGL zu sehen, deshalb ähneln beide sich in Aufbau und Programmierstil. OpenAL gibt es wie OpenGL für viele verschiedene Plattformen. Sie ist direkter Konkurrent zu Microsofts Direct Sound, welcher wiederum Bestandteil von DirectX ist. Da OpenAL sehr gut zu portieren ist, hat es bis heute eine weite Verbreitung gefunden. Es gibt zahlreiche Programme, Spiele und Engines, die OpenAL nutzen zum Beispiel Doom 3, Quake 4, Battlefield 2 u.v.a. OpenAL werde ich in dieser nur kurz erwähnen, da es in der Lehrveranstaltung nicht direkt um Audio geht. 4.3 Java Input API (JInput) Diese Bibliothek ist standardmäßig bei LWJGL dabei und kann eingebunden werden, falls diese benötigt wird. Auch ohne diese Bibliothek kann LWJGL bereits Keyboard-, Maus-- und Controllereingaben behandeln, wird aber durch JInput nochmals erweitert. Beim Java Input API handelt es sich um ein Projekt zur Implementierung einer Open-Source-API für Game-Controller. Entwickelt von der Game Technology Group von Sun, gewährleistet es die Möglichkeit in Java high-performance Spiele zu realisieren. Der Standard ist ebenfalls plattformunabhängig und portabel. Er unterstützt die verschiedensten Controller und liefert sowohl dem Menschen als auch der Maschine verständliche Beschreibungen der Eingabe. 4.4 FMOD Bei FMOD handelt es sich um eine Musik-Bibliothek die es ermöglicht auf verschiedenen Plattformen die verschiedensten Dateiformate für Musik wiederzugeben. In LWJGL wir FMOD 3 verwendet. Dieser Standard unterstützt Windows, Macintosh, Linux sowie die Konsolen Playstation2, Playstation Portable, Xbox, Nintendo Game Cube und Wii. Hierbei werden sehr viele Musikformate unterstützt z. B. MP3, AIFF, ASF, M3U, MP2, OGG, WAV, WMA usw. Somit eignet sich dieser Standard besonders gut zur Spielentwicklung und kann ohne Änderungen am Code auf verschiedene Plattformen übertragen werden. 4.5 DevIL (Developers Image Library, ehemals OpenIL) DevIL ist eine Bibliothek, mit der man Anwendungen entwickeln kann, bei denen es hauptsächlich auf die Fähigkeit ankommt Bilder zu laden und zu bearbeiten. DevIL ermöglicht es mit einer effizienten und einfachen Syntax Bilder und Images zu laden, speichern, konvertieren, bearbeiten und zu filtern. Wie FMOD unterstützt es viele verschieden Format. Es kann folgende Formate laden: bmp,.cut,.dds,.doom,.gif,.ico,.jpg,.lbm,.mdl,.pic,.png,.ppm,.raw,.sgi,.tga,.tif u.v.m. Zum Speichern stehen diese Formate zur Verfügung:.bmp,.dds,.h,.jpg,.pal,.pbm,.pcx,.hdr,.pgm,.png,.ppm,.raw,.sgi,.tga und.tif. 7

8 4.6 Fazit Durch den speziellen Aufbau von LWJGL und die vielen zusätzlichen Bibliotheken die man zusammen mit LWJGL verwenden kann, entsteht eine mächtige, plattformunabhängige Entwicklungsumgebung für die Spiele- Entwicklung unter Java. Im weiteren Verlauf dieser werde ich aber nur auf die Grundbestandteile von LWJGL eingehen, d. h. hauptsächlich auf OpenGL und kurz auf OpenAL. Die zusätzlichen Bibliotheken werde ich nicht weiter betrachten. 5. Ausschnitt aus der Klassenhierarchie Die Lightweight Java Games Library ist im Paket org.lwjgl definiert. In folgender Tabelle sind die wichtigsten Klassen in alphabetischer Reihenfolge mit einer kleinen Erläuterung aufgeführt. Unten ist zunächst ein Auszug der Klassenhierarchie des Packages org.lwjgl zu sehen: java.lang.object org.lwjgl.openal.al org.lwjgl.openal.al10 org.lwjgl.openal.al11 org.lwjgl.opengl.display org.lwjgl.opengl.displaymode org.lwjgl.fmod3.fmod org.lwjgl.opengl.gl11 org.lwjgl.opengl.gl12 org.lwjgl.opengl.gl13 org.lwjgl.opengl.gl14 org.lwjgl.opengl.gl15 org.lwjgl.opengl.gl20 org.lwjgl.opengl.gl21 org.lwjgl.opengl.glu.glu org.lwjgl.input.keyboard org.lwjgl.input.mouse org.lwjgl.opengl.glu.quadric org.lwjgl.opengl.glu.cylinder org.lwjgl.opengl.glu.disk org.lwjgl.opengl.glu.partialdisk org.lwjgl.opengl.glu.sphere org.lwjgl.sys 8

9 Klasse AL Display DisplayMode FMOD GL11-GL21 GLU Keyboard Mouse Quadric Sys Beschreibung enthält Methoden um eine Verlinkung zur nativen OpenAL-Bibliothek herzustellen. Die Klassen AL10 und AL11 stellen dann alle Methoden zur Verfügung um die Funktionen von OpenAL in Java nutzen zu können. Hierbei stellen die Nummern meiner Meinung nach die Versionsnummern der Bibliothek dar. D. h. AL11 erhält alle Neuerungen die in AL10 noch nicht vorhanden waren. erzeugt ein Window und den OpenGL-Kontext in dem die Szene gerendert wird. Display spricht die Graphikkarte an und enthält Methoden um Auflösung, Helligkeit, Kontrast, Bildwiederholfrequenz u.v.m zu verändern. enthält die Daten des Displays (Auflösung, Höhe, Breite) und kann über Display.getAvailableDisplayModes alle verfügbaren Auflösungen bzw. Daten in einem Array DisplayMode[] speichern. stellt die FMOD-Bibliothek dar und erzeugt eine Instanz von ihr, die man unter Java verwenden kann enthält die Methoden der OpenGL-Bibliotheken, um verschiedene Arten von Szenen zu erzeugen. Dabei stehen die Nummern (z. B. GL14 = OpenGL 1.4) meiner Meinung nach auch für die jeweilige Version der Bibliothek. Die Namen der Methoden wurden beibehalten und können 1 zu 1 verwendet werden. beinhaltet die wichtigsten Methoden der GLU-Bibliothek. Im Wesentlichen gluperspective, gluortho2d und glulookat. stellt ein Interface zur Tastatur dar, welches den aktuellen Zustand der Tastatur abfragt und auf Drücken/Loslassen einer Taste reagiert. Eine wichtige Methode ist hierbei iskeydown(int key), um bei einem Tastendruck bestimmte Aktionen zu veranlassen. ermöglicht es auf Eingaben mit der Maus entsprechend zu reagieren. Es kann die Position des Mauszeigers, die Tasten und das Scrollrad abgefragt werden. enthält Methoden um die Eigenschaften von Quadriken zu beeinflussen z. B. Normalenvektoren, Orientierung usw. Es ist möglich die Quadriken Cylinder, Disk, PartialDisk und Sphere zu erzeugen und zu verwenden. stellt eine Systemklasse dar, die ähnlich wie java.lang.system verschiedene Möglichkeiten bietet, das System zu verwenden. So kann man z. B. dem User einen Fehler melden (alert), eine URL aufrufen (openurl) oder die Systemzeit ermitteln (gettime) Tab. 1: : Beschreibung der wichtigsten Klassen der LWJGL (in Anlehnung an /M3G/) 6. Installation von LWJGL Damit man LWJGL verwenden kann benötigt man die oben genannten Pakete. Diese kann man sich unter folgenden Internetadressen herunterladen: oder Hier findet man auch eine Dokumentation und die entsprechenden optionalen Pakete. In der Datei lwjgl zip findet man alles was man für den Anfang benötigt. Unterstützt werde die Betriebssysteme Windows, Unix und MacOS. 9

10 6.1 Windows a) Als ersten Schritt entpackt man das Archiv lwjgl zip.. Dieses sollte unter anderen folgende Dateien enthalten: lwjgl.dll lwjglaudio.dll lwjgl.jar lwjgl_util.jar lwjgl_test.jar b) Um LWJGL zu testen, muss man in das Verzeichnis wechseln in das entpackt wurde und in die Kommandozeile folgenden Befehl eintippen. Achtung: alles in eine Zeile eingeben und Leerzeichen vor jeder - Option : java -cp.;res;jar\lwjgl.jar;jar\lwjgl_test.jar;jar\lwjgl_util.jar;jar\lwjgl _fmod3.jar;jar\lwjgl_devil.jar;jar\jinput.jar; - Djava.library.path=native\win32 org.lwjgl.test.windowcreationtest Ein Fenster müsste sich öffnen und folgende Ausgaben müssten in der Konsole erscheinen: 10 Abb. 2: Funktionstest der LWJGL unter Windows (Vista)

11 6.2 Linux/Unix a) Als ersten Schritt entpackt man das Archiv lwjgl zip.. Dieses sollte unter anderen folgende Dateien enthalten: liblwjgl.so libopenal.so lwjgl.jarl.jar lwjgl_util.jar lwjgl_test.jar b) Um LWJGL zu testen, muss man in das Verzeichnis wechseln in das entpackt wurde und in die Kommandozeile folgenden Befehl eintippen. Achtung: alles in eine Zeile eingeben und Leerzeichen vor jeder - Option : java -cp.:res:jar/lwjgl.jar:jar/lwjgl_test.jar:jar/lwjgl_util.jar:jar/lwjgl _fmod3.jar:jar/lwjgl_devil.jar:jar/jinput.jar: -Djava.library.path= Djava.library.path=native/linux org.lwjgl.test.windowcreationtest Sollte ein Fehler auftreten, sollte man bei -Djava.library.path versuchen den Pfad manuell angeben. Zum Beispiel: java -cp.:res:jar/lwjgl.jar:jar/lwjgl_test.jar:jar/lwjgl_util.jar:jar/lwjgl _fmod3.jar:jar/lwjgl_devil.jar:jar/jinput.jar: - Djava.library.path=/home/lwjgluser/lwjgl/org.lwjgl.test.WindowCreatorg.lwjgl.test.WindowCreat iontest Auch hier müsste sich ein Fenster öffnen und folgende Ausgaben in der Konsole erscheinen: 11 Abb. 3: Funktionstest der LWJGL unter Linux (Suse 10.3)

12 6.3 MacOS a) Hier entpackt man ebenfalls das Archiv lwjgl zip.. Dieses sollte unter anderen folgende Dateien enthalten: liblwjgl.jnilib openal.dylib lwjgl.jar lwjgl_util.jar lwjgl_test.jar b) Um LWJGL zu testen, muss man in das Verzeichnis wechseln in das entpackt wurde und in die Kommandozeile folgenden Befehl eintippen. Achtung: alles in eine Zeile eingeben und Leerzeichen vor jeder - Option : java cp.:res:jar/lwjgl.jar:jar/lwjgl_test.jar:jar/lwjgl_util.jar:jar/ lwjgl_fmod3.jar:jar/lwjgl_devil.jar:jar/jinput.jar: jar:jar/jinput.jar: - Djava.library.path=native/macosx org.lwjgl.test.windowcreationtest Ähnlich wie bei Windows und Linux müsste sich auch hier ein Fenster öffnen, indem die Ausgaben erscheinen. Leider konnte ich dies nicht testen, da ich kein System besitze auf dem MacOS läuft. 12

13 7. Einrichten der Entwicklungsumgebung für LWJGL 7.1 Eclipse a) Nachdem man die Dateien entpackt und die Funktion von LWJGL getestet hat, kann man Eclipse starten. b) Danach muss man sich ein neues Projekt erzeugen und die lwjgl.jar zum Java Build Path hinzufügen (Project Properties Java Build Path), indem man unter dem Reiter Libraries auf Add External JARs klickt. Abb. 4: Hinzufügen von lwjgl.jar zum Java Build Path c) Nachdem dem nun eine Klasse erstellt hat, kann man diese übersetzen indem man auf Run klickt und das Menü verwendet (Run OpenRunDialog ). 13 Abb. 5: Run-Dialog öffnen

14 d) Es öffnet sich ein neues Fenster. Dort wählt man die entsprechende Klasse aus und wählt den Reiter Arguments aus. Im Fenster für die VM-Argumente gibt man an wo die dll-dateien liegen die zum Pfad (-Djava.library.path = Dein Pfad ) hinzugefügt werden sollen. Die dll-dateien müssen hierfür ins Projektverzeichnis kopiert werden (diese liegen im entpackten LWJGL-Verzeichnis unter /native/win32 bzw. linux bzw. macosx) Abb. 6: DLL-Dateien Dateien zum Projekt hinzufügen e) Dann nur noch auf den Run -Button klicken und das Programm sollte laufen. f) Um die Schritte c) bis e) nicht bei jeder Übersetzung wiederholen zu müssen, kann man die DLL-Dateien und evtl. auch die JAR-Dateien in sein Java-JDK- Verzeichnis kopieren. Diese JDK-Version muss dann von Eclipse verwendet werden. Die DLLs z. B. nach C:\Program Files\Java\jre1.6.0_03\bin kopieren. Die JARs z. B. nach C:\Program Files\Java\jre1.6.0_03\lib\ext ext kopieren. Die JAR- Dateien müssen dann nur noch als externe JARs in die Entwicklungsumgebung von Eclipse integriert werden. 7.2 Netbeans Hierfür befindet sich die Anleitung im Anhang unter 10.2 Einrichten der Entwicklungsumgebung Netbeans. 14

15 8. Praktischer Teil / Tutorial In diesem Kapitel möchte ich auf die Programmierung mittels LWJGL eingehen. Hierzu werde ich Schritt für Schritt ein einfaches Programm erstellen, das die Möglichkeiten der API darstellen soll. Weitere Programmierbeispiele findet man auf der Internetseite des LWJGL-Projekts unter Diese befinden sich aber auch im Package lwjgl_test.jar und können mit Java übersetzt und getestet werden. 8.1 Das Grundgerüst einer LWJGL-Klasse Der erste Schritt zur Implementierung einer Applikation soll das Erstellen eines simplen Grundgerüsts einer LWJGL-Klasse sein. Dieses soll den Aufbau, der bei jeder Klasse verwendet wird darstellen. Dieses Grundgerüst hat an sich keine Funktion es öffnet nur ein schwarzes Fenster, dass mit ESC beendet werden kann. Nun möchte ich dieses Gerüst kurz erläutern. Das untere Bild stellt die Import- Anweisungen und die Mainmethode dar: Quelltext 1: Importanweisungen und Main-Methode der Klasse Grundgerüst 15

16 Um Fehler und sonstige Ausgaben handeln zu können, wird die Klasse org.lwjgl.sys importiert. Desweiteren werden für die Tastatureingaben und die Erstellung des Kontexts die Klassen Keyboard und Display benötigt. Als wichtigste Klasse wird GL11 angesehen, da mit ihr die Funktionen von OpenGL zur Verfügung gestellt werden. Nun zum eigentlichen Programm und zur Main-Methode. Methode. Hier werden nur die Methoden init() zur Erstellung eines Displays und die run()-methode aufgerufen. Der try-catch-block wird benötigt um evtl. Fehler abzufangen. Die Methode cleanup() übernimmt Aufräumarbeiten und schließt das Fenster. Das nächste Bild zeigt den Quellcode der Methoden init() und run(): Quelltext 2: Methode init() und run() der Klasse Grundgerüst Um Graphiken anzuzeigen, braucht man als erstes ein Display ( Window ), welches zugleich den OpenGL Kontext darstellt. Dieses kann man sich direkt mit create() erzeugen (Zeile 45). Wenn vorher nichts weiter eingestellt wird, wird ein Fenster mit der aktuellen Auflösung des Bildschirms erstellt. Vorher wird das Display auf Fullscreen eingestellt (Zeile 43). 16

17 Da es in der LWJGL die Methode glmainloop() nicht gibt, muss man sich diese selbst erstellen (hier die run()-methode). Sie besteht im Wesentlichen aus einer while- Schleife, die prüft ob das Spiel noch läuft oder schon beendet wurde. Um Änderungen der Ausgabe sofort darzustellen wird das Display ständig aktualisiert (Zeile 55). Um heraus zu finden ob ein n Schließen des Displays vom Benutzer oder Betriebssystem angefordert wird, ruft man in Zeile 57 iscloserequest() auf und beendet die Main-Loop. Solange das Fenster jedoch im Vordergrund ist wird gerendert und auf Tastatur-Eingaben geprüft (Zeile 62-66). Als letztes noch der Quellcode der Methoden close(), cleanup() und render(): Quelltext 3: Methode close() und cleanup() der Klasse Grundgerüst 17 Die Methode close() ist dazu gedacht zu prüfen ob der Benutzer die ESC-Taste gedrückt hat. Hierfür wird die Methode iskeydown() der Klasse Keyboard aufgerufen und geprüft ob es sich um die ESC-Taste handelt. Ist dies der Fall, wird das Programm beendet. Die cleanup()-methode ist dafür verantwortlich, dass erzeugte Display wieder zu zerstören und somit das Fenster zu schließen und das Rendern zu beenden. render() ist die wichtigste Methode da hier das Objekt gezeichnet wird. Hier können alle Methoden die OpenGL zum Erstellen eines Objekts bereit stellt eingefügt werden. Hier wird aber nur ein schwarzer Bildschirm erzeugt.

18 Abb. 7: Das Spiel Ping Pong 8.2 Das Spiel PingPong Nachdem man nun das Grundgerüst kennt, kann man beliebige Funktionen hinzufügen. Ich möchte nun die Implementierung des Spiels Ping Pong erklären. Hierbei handelt es sich um die Nachempfindung eines der ersten PC- Spiele aus den 80iger Jahren. Die Schläger können entweder mit dem Keyboard oder der Maus gesteuert werden Initialisierung Die Initialisierung läuft ähnlich wie bei dem Grundgerüst ab. Hier müssen aber zusätzlich noch die Maus und das Keyboard erzeugt werden. 18 Quelltext 4: Methode init() und initwindow() der Klasse PingPong2

19 Bei der Initialisierung des Displays wird das Fenster r diesmal nicht auf Vollbild gesetzt. Außerdem werden beim Erstellen die jeweiligen Displaygrenzen gespeichert, um feststellen zu können, wann der Spielball sich im AUS befindet. Hierzu wird die Methode getdisplaymode() des Display-Objekts aufgerufen. Sie liefert die Parameter des Bildschirms. Mit getheight() lässt man sich die Höhe und d mit getwidth() die Breite geben. Da der Bezugspunkt der Szene im Mittelpunkt des Bildschirms liegen soll, wird das Ganze noch durch zwei geteilt und für unten und links einfach negiert. Somit stellen rechts, links, oben und unten die Grenzen des Bildschirms dar. Nachdem das Display nun erstellt wurde müssen noch ein Keyboard und eine Maus zur Steuerung des Spiels zur Verfügung gestellt werden. Quelltext 5: Methode initmouse() und initkeyboard() der Klasse PingPong2 19 Durch die create()-methoden werden sowohl die Maus als auch das Keyboard erstellt und initialisiert. Da dies zu einem Fehler führen kann, muss man die LWJGLExeception abfangen und eine Fehlermeldung über die Klasse Sys ausgeben. Um den Mauszeiger definiert auf eine bestimmte Position zu setzen ruft man setcursorposition(int x, int y) auf. Da der Bezugspunkt der Maus im linken unteren Eck liegt, verschiebt man mit x = rechts und y = oben den Zeiger genau in den Mittelpunkt der Szene.

20 8.2.2 Steuerung Das Spiel kann entweder mit der Tastatur oder der Maus gesteuert werden, um die Schläger in ihre Position zu bringen. Quelltext 6: Methode checkkeyboardinput() der Klasse PingPong2 Um mit der Tastatur steuern zu können, gibt es die Methode checkkeyboardinput(). Falls noch kein Keyboard existiert bzw. dieses durch die Methode gameover() (dazu später mehr) zerstört wurde, muss es erneut initialisiert werden. Hierzu verwendet man iscreated(). Je nach dem welche Taste gedrückt wurde, bewegt sich der Schläger um VS Pixel nach oben oder nach unten, falls die Grenzen noch nicht erreicht wurden. VS deshalb weil hierdurch die Geschwindigkeit der Schläger bestimmt wird (V Schläger). Die Variablen yposs1 und yposs2 entsprechen der Y- Position der Schläger (Mittelpunkt). Um mit der Maus ebenso steuern zu können gibt es die Methode checkmouseinput(). 20 Quelltext 7: Methode checkmouseinput() der Klasse PingPong2

21 Der Ablauf ist ähnlich wie bei der Methode für das Keyboard. Falls noch keine Maus existiert oder diese zerstört wurde, wird neu initialisiert. Wird die rechte bzw. linke Maustaste betätigt, wird der rechte bzw. linke Schläger auf Mausansteuerung umgeschaltet. Die Position der Schläger wird dann auf die des Mauszeigers gesetzt, wobei man wieder beachten muss, dasss der Bezugspunkt der Maus nicht dem der Szene entspricht Objekte Die Objekte des Spiels Ping Pong werden mit Hilfe des OpenGL- Bindings der LWJGL erzeugt. Hierfür wird im Wesentlichen die Klasse GL11 verwendet die die Methoden zum Zeichen von Vertex-Punkten bereitstellt. Hier werden die Methoden glvertex2f und glcolor3f verwendet. Quelltext 8: Methode drawpaddles() und drawball() der Klasse PingPong2 Die beiden Methoden drawpaddles() und drawball() zeichnen die drei Objekte, die für das Spiel benötigt werden. Die beiden Schläger werden relativ zu den Grenzen des Displays um 20 Pixel nach innen verschoben. Jeder Schläger hat eine Breite von 20 Pixeln. LS entspricht der Länge der Schläger (L Schläger) bzw. der halben 21

22 Länge des Schlägers. Je nach dem wo sich gerade der Mittelpunkt der Schläger befindet (ypossx), wird dort neu gezeichnet. Beim Ball verhält es sich ähnlich. Dieser kann sich jedoch auch in x- Richtung verändern. Je nach dem wo sich h der Mittelpunkt des Ball-Objekts gerade befindet wird dort mit der (doppelten) Kantenlänge von BALLKANTE neu gezeichnet Bewegung des Balls Um den Ball richtig von n den Ränder und den Schlägern abprallen zu lassen, wird die Methode bounce() benötigt. Je nach dem wie der Ball auf die Flächen trifft, wird dieser zurück geworfen. Der Vektor (dx/dy) bestimmt die Richtung des Balls. Quelltext 9: Methode bounce() der Klasse PingPong2 Als erstes benötigt man die x-positionen der Schläger um den Ball dort Abprallen zu lassen. Diese Positionen werden durch xposs1 und xposs2 bestimmt. Fall der Ball die obere bzw. untere Grenze überschreitet wird er auf die Grenzwerte zurückgesetzt und der Eintrittswinkel gleich dem Austrittswinkel gesetzt (dy = -dy). 22

23 Ähnlich verhält es sich, falls der Ball auf einen der Schläger auftrifft. Auch hier wird die Bewegungsrichtung des Balls umgekehrt (dx = -dx). Damit der Ball aber auch schräg abprallt, wird dy in Abhängigkeit der y-werte des Balls und des Schlägers verändert. Damit sich kleine Änderugen des Schlägers nicht zu stark auf den Abprallwinkel des Balls auswirken, muss man durch 50 teilen. Damit der Ball überhaupt am Schläger abprallt, muss sich dieser natürlich in dem Bereich befinden in dem der Schläger gerade steht. Ansonsten ist das Spiel verloren Rendering Damit die Szene jetzt noch auf dem Display angezeigt werden kann muss diese noch gerendert werden. Da die Objekte nicht komplex sind, muss man hierbei jedoch nicht gar soviel beachten. Hierfür gibt es die Methode render(). Quelltext 10: Methode render() der Klasse PingPong2 Als erstes wird der Color-Buffer gelöscht und somit ein schwarzer Hintergrund erzeugt. Danach muss die Einheitsmatrix gepusht und später wieder gepoppt werden, damit nicht die Transformationsmatrix ständig addiert wird und somit die Szene immer weiter verschoben wird. Die Transformation bewirkt, dass der Bezugspunkt der Szene im Mittelpunkt des Bildschirms liegt. Danach werden die Schläger und der Ball in die Szene gerendert Main-Loop Wie beim Grundgerüst muss die Main-Loop wieder manuell erzeugt werden. Im Unterschied zum Grundgerüst werden bei dem Spiel Ping- Pong einige Methoden mehr aufgerufen. Es wird der Bewegungsvektor des Balls ausgewertet und die Position des Balls aktualisiert, welcher anschließend neu gerendert wird. Außerdem wird geprüft ob der Ball gerade irgendwo abprallt. Außerdem wird auf Tastatur- und Mauseingaben überprüft. 23

24 Quelltext 11: Methode run() der Klasse PingPong Spielende Das Spiel ist zu Ende, falls einer der Spieler den Ball in das Aus des Gegners befördert. Dies wird in der Methode bounce() überprüft. Ist dies der Fall wird die Methode gameover() aufgerufen. 24 Quelltext 12: Methode gameover() der Klasse PingPong2 Falls ein Spieler verloren hat, wird als erstes eine Meldung ausgegeben. Danach werden die Schläger und er Ball wieder in den Anfangszustand versetzt. Auch der Bewegungsvektor des Spielballs wird auf den Anfang zurück gesetzt. Danach muss noch das Keyboard und die Maus zerstört werden, um zu gewährleisten, dass Tasten die noch betätigt waren als der Ball in das Aus befördert wurde, gelöscht werden. Die Eingabegeräte werden dann in den Methoden checkkeyboardinput() und checkmouseinput() neu erzeugt und sind somit wieder verwendbar.

25 9. Schlusswort Ich hoffe ich konnte jedem der diese gelesen hat, aufzeigen, dass es mit der LWJGL sehr einfach ist OpenGL unter Java zu verwenden. Auch Tastatur- Maus- oder Controller-Eingaben können ganz leicht abgefragt werden. An dem praktischen Beispiel sieht man,, wenigsten im Ansatz, dass man mit der LWJGL sehr gut Spiele entwickeln kann. Leider konnte ich im Rahmen der nicht sehr detailiert auf die OpenAL eingehen, die ja auch Bestandteil von LWJGL ist. Dies hätte leider den zeitlichen Rahmen und den Umfang der Dokumentation gesprengt. Jedoch ist mir bei einigen Experimenten mit der LWJGL und OpenAL aufgefallen, dass es unter Windows Vista scheinbar Probleme mit der Methode WaveData.create(String datei) und WaveData.create(URL url) gibt. Dies ist mir an dem Beispielcode der Klasse OpenALCreationTest aufgefallen. Ob das nun speziell an meinem System lag oder generell unter Vista auftritt,, konnte ich leider nicht in Erfahrungen bringen. Die Lösung jedoch ist, dass es diese Methode noch in einer dritten Ausführung gibt und zwar WaveData.create(InputStream daten). Diese Variante funktionierte auch unter Windows Vista. Weitere Beispiele für die Verwendung von OpenAL und LWJGL findet man auch auf der Homepage des Projekts (siehe Einleitung Kapitel 8). Desweiteren ist mir aufgefallen, dass die in der gezeigten Programme auf den Rechner im CAE-Labor wesentlich schneller ausgeführt werden. Leider konnte ich dies nicht in das Tutorial einfügen. Die Lösung ist jedoch, dass man bei der Initialisierung des Bildschirms die Methode Display.setVSyncEnabled(true) aufruft und in der Main-Loop (run()-methode) den Bildschirm immer synchronisiert. Dazu benutzt man die Methode Display.sync(int framerate). Dies war auch das einzige erwähnenswerte Problem, das ich mit der Bibliothek hatte. Ansonsten verlief alles reibungslos und man kann genau nach dem Schema vorgehen, das auf den vorherigen Seiten beschreiben wurde. 25

26 10. Anhang 10.1 Quellen /DEV/ /EVIL/ /FMOD/ /JINPUT/ /LWJGL1/ /LWJGL2/ /M3G/ /OPENAL/ /OPENGL/ /TOS/ /WIKI1/ /WIKI2/ /WIKI3/ /WIKI4/ /WIKI5/ /WIKI6/ /WIKI7/ DevIL Project: Behrendt, Benjamin: devil.com/index.php?menu=tutorials&cat=java&content=java_lwjgl FMOD Company: Java Input API Project: LWJGL Project: (mit allen Unterlinks) LWJGL Forum: Werder, Jironimo: Mobile 3D Graphics API Cross-Platform 3D Audio: The Industry's Foundation for High Performance Graphics: Schuster, Thomas: Entwicklung einer isometrischen Graphik- Engine in Java,, Diplomarbeit vom August 2004, S. 39 Wikipedia LWJGL: Wikipedia FMOD: Wikipedia DevIL: Wikipedia OpenAL: Wikipedia OpenGL: Devmaster Wiki: Wikipedia DirectX: 26

27 10.2 Einrichten der Entwicklungsumgebung Netbeans Nachdem man wie in Kapitel 6 beschrieben die Funktionalität der LWJGL getestet hat, kann man mit der Einrichtung von Netbeans beginnen. a) Man klickt auf Extras Bibliotheksverwaltung. Es öffnet sich ein Fenster und man klickt auf Neue Bibliothek. Nun gibt man den Namen der neuen Bibliothek ein. b) Die neu erstellte Bibliothek wählt man aus und klickt auf JAR/Verzeichnis hinzufügen und wählt die LWJGL-JARs JARs aus. Danach bestätigt man mit OK. 27

28 c) Nun wählt man das Projekt aus, in dem man die LWJGL verwenden möchte und macht einen Rechtsklick darauf. Man wählt Eigenschaften aus. 28

29 d) Darauf hin öffnet sich ein neues Fenster, bei dem man links im Feld Bibliotheken auswählt und dann noch auf Bibliotheken hinzufügen im rechten Feld klickt. e) Hier wählt man die vorher erstellte LWJGL-Bibliothek aus und bestätigt mit Bibliothek hinzufügen. f) Als nächstes wählt man im Eigenschaftsfenster Ausführen aus und gibt unter Optionen für die VM den Pfad der DLL-Dateien an. Danach bestätigt man mit OK. Die DLL s sollte man vorher in das Projektverzeichnis kopieren. g) Das Projekt müsste sich jetzt übersetzen lassen. 29